LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteOsOpen
UNQLITE_PRIVATE int unqliteOsOpen(
  unqlite_vfs *pVfs,
  SyMemBackend *pAlloc,
  const char *zPath, 
  unqlite_file **ppOut, 
  unsigned int flags 
)
{
	unqlite_file *pFile;
	int rc;
	*ppOut = 0;
	if( zPath == 0 ){
		/* May happen if dealing with an in-memory database */
		return SXERR_EMPTY;
	}
	/* Allocate a new instance */
	pFile = (unqlite_file *)SyMemBackendAlloc(pAlloc,sizeof(unqlite_file)+pVfs->szOsFile);
	if( pFile == 0 ){
		return UNQLITE_NOMEM;
	}
	/* Zero the structure */
	SyZero(pFile,sizeof(unqlite_file)+pVfs->szOsFile);
	/* Invoke the xOpen method of the underlying VFS */
	rc = pVfs->xOpen(pVfs, zPath, pFile, flags);
	if( rc != UNQLITE_OK ){
		SyMemBackendFree(pAlloc,pFile);
		pFile = 0;
	}
	*ppOut = pFile;
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rcx)
testq %rdx, %rdx
je 0x3bdd4
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movl %r8d, -0x2c(%rbp)
movl 0xc(%rdi), %esi
addl $0x8, %esi
movq %r14, %rdi
callq 0x343ed
testq %rax, %rax
je 0x3bddc
movq %rax, %r15
movl 0xc(%r13), %ecx
addl $0x8, %ecx
je 0x3bdaa
movq %r15, %rax
addq %rcx, %rax
movq %r15, %rcx
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3bdaa
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3bdaa
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3bdaa
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jb 0x3bd7e
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl -0x2c(%rbp), %ecx
callq *0x18(%r13)
movl %eax, %r12d
testl %eax, %eax
je 0x3bdcf
movq %r14, %rdi
movq %r15, %rsi
callq 0x3503f
xorl %r15d, %r15d
movq %r15, (%rbx)
jmp 0x3bde2
movl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
jmp 0x3bde2
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_wait_on_lock
static int pager_wait_on_lock(Pager *pPager, int locktype){
  int rc;                              /* Return code */
  do {
    rc = pager_lock_db(pPager,locktype);
  }while( rc==UNQLITE_BUSY && pPager->xBusyHandler && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x3c3e0
movl %eax, %r15d
cmpl $-0xe, %eax
jne 0x3be2e
movq 0x178(%r14), %rax
testq %rax, %rax
je 0x3be2e
movq 0x180(%r14), %rdi
callq *%rax
testl %eax, %eax
jne 0x3be03
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_lock_db
static int pager_lock_db(Pager *pPager, int eLock){
  int rc = UNQLITE_OK;
  if( pPager->iLock < eLock || pPager->iLock == NO_LOCK ){
    rc = unqliteOsLock(pPager->pfd, eLock);
    if( rc==UNQLITE_OK ){
      pPager->iLock = eLock;
    }else{
		unqliteGenError(pPager->pDb,
			rc == UNQLITE_BUSY ? "Another process or thread hold the requested lock" : "Error while requesting database lock"
			);
	}
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpl %esi, 0x1f4(%rdi)
jge 0x3c436
movl %esi, %r15d
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testl %eax, %eax
je 0x3c42f
movl %eax, %r12d
movq 0x8(%r14), %rdi
cmpl $-0xe, %eax
leaq 0x396ca(%rip), %rax     # 0x75ae4
leaq 0x396f5(%rip), %rsi     # 0x75b16
cmoveq %rax, %rsi
callq 0x31af5
movl %r12d, %ebx
jmp 0x3c436
movl %r15d, 0x1f4(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3c4d9
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 0x3c4d9
cmpq %rsi, 0x10(%rax)
je 0x3c4db
movq 0x48(%rax), %rax
jmp 0x3c4c8
xorl %eax, %eax
testq %rax, %rax
je 0x3c4f4
movq (%rax), %rsi
movl 0x208(%rdi), %eax
movq %rdx, %rdi
movl %eax, %edx
popq %rbp
jmp 0x34fc5
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x386bc(%rip), %rdi     # 0x74bc6
movl $0x8, %edx
callq 0x34fc5
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_O1/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 0x3c3e0
testl %eax, %eax
je 0x3c584
movl $0x1, (%r14)
xorl %ebx, %ebx
cmpl $0x0, 0x204(%r15)
je 0x3c5a1
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 0x3c5d0
cmpl $0x0, 0x60(%r15)
je 0x3c5d0
movl %eax, %ebx
jmp 0x3c590
movq 0x38(%r15), %rdi
movq (%rdi), %rax
movl $0x2, %esi
callq *0x28(%rax)
testl %r12d, %r12d
je 0x3c635
movl %eax, %r13d
movq 0x38(%r15), %r12
testq %r12, %r12
je 0x3c619
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 0x3503f
cmpl $0x0, -0x2c(%rbp)
setne %al
jmp 0x3c61b
xorl %eax, %eax
testl %r13d, %r13d
setne %cl
testb %cl, %al
je 0x3c62d
movl %r13d, %ebx
jmp 0x3c590
movq $0x0, 0x38(%r15)
cmpl $0x1, (%r14)
jne 0x3c590
movq %r15, %rdi
movl $0x4, %esi
callq 0x3c3e0
testl %eax, %eax
jne 0x3c590
movl $0x0, (%r14)
jmp 0x3c590
// File: /workspace/github_c_makefile_star2_O1/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 0x3c6d4
leaq -0x68(%rbp), %rax
movq %rsi, %r8
movq %rdi, %r9
movq 0x10(%r9), %rcx
cmpq 0x10(%r8), %rcx
jae 0x3c6a7
movq %r9, 0x60(%rax)
movq %rax, 0x58(%r9)
movq 0x60(%r9), %rdi
movq %r8, %rsi
movq %r9, %rax
jmp 0x3c6b9
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 0x3c6d8
movq %rsi, %r8
movq %rdi, %r9
testq %rsi, %rsi
jne 0x3c689
jmp 0x3c6d8
leaq -0x68(%rbp), %rax
testb %dl, %dl
je 0x3c6e6
movq %rdi, 0x60(%rax)
movq %rax, 0x58(%rdi)
jmp 0x3c6fb
testb %cl, %cl
je 0x3c6f4
movq %rsi, 0x60(%rax)
movq %rax, 0x58(%rsi)
jmp 0x3c6fb
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x3c716
movq 0x50(%rsi), %rcx
movq %rcx, 0x50(%rax)
movq 0x50(%rsi), %rcx
testq %rcx, %rcx
je 0x3c725
addq $0x48, %rcx
jmp 0x3c73b
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 0x3c755
movq 0x28(%rax), %rax
movq %rax, 0x228(%rdi)
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x3c766
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rax)
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x3c773
movq %rax, 0x30(%rcx)
decl 0x254(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3c7bc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x188(%rdi), %rax
testq %rax, %rax
je 0x3c7a5
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3c7a5
callq *%rax
movq $0x0, 0x8(%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2eb38
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: WriteInt64
static int WriteInt64(unqlite_file *pFd,sxu64 iNum,sxi64 iOfft)
{
	unsigned char zBuf[8];
	int rc;
	SyBigEndianPack64(zBuf,iNum);
	rc = unqliteOsWrite(pFd,zBuf,sizeof(zBuf),iOfft);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdx, %rcx
bswapq %rsi
leaq -0x8(%rbp), %rax
movq %rsi, (%rax)
movq (%rdi), %r8
movl $0x8, %edx
movq %rax, %rsi
callq *0x18(%r8)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e951
testq %rax, %rax
je 0x3c976
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x14, %rcx
jb 0x3c870
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 0x3c976
movq (%rbx), %rdi
movl %r12d, %r15d
shll $0x4, %r15d
movl %r15d, %esi
callq 0x343ed
testq %rax, %rax
je 0x3c976
movq %rax, %r14
testl %r15d, %r15d
je 0x3c92c
movl %r15d, %ecx
movq %r14, %rax
addq %rcx, %rax
movq %r14, %rcx
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3c92c
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3c92c
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3c92c
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jb 0x3c900
addl %r12d, %r12d
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x3c962
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 0x3c93f
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x3503f
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_O1/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 0x3ca01
movq 0x18(%rbx), %r15
movq 0x8(%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2eb38
decl 0x8(%rbx)
je 0x3ca01
movq 0x8(%r12), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x2eb38
decl 0x8(%rbx)
je 0x3ca01
movq 0x8(%r15), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2eb38
decl 0x8(%rbx)
je 0x3ca01
movq 0x8(%r12), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x2eb38
decl 0x8(%rbx)
jne 0x3c9af
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x3503f
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3503f
// File: /workspace/github_c_makefile_star2_O1/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 0x3caf8
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3cb0c
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x3cb3b
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x39452(%rip), %rcx     # 0x75f5c
jmp 0x3cb1e
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x39456(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x3cbc4
movq (%rdx), %rdi
leaq -0x24(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movl (%r15), %r15d
testl %r15d, %r15d
jle 0x3cbd8
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 0x3dde0
testq %rax, %rax
jne 0x3cbf4
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x3deac
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x3cbf7
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x39386(%rip), %rcx     # 0x75f5c
jmp 0x3cbea
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x3938a(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x3cc93
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3cca7
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3ccd7
movq %rax, %r15
movq %rbx, %rdi
callq 0x317a5
testq %rax, %rax
je 0x3ccbb
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x40e96
movq 0x8(%rbx), %rsi
testl %eax, %eax
je 0x3cced
movq %rsi, %rdi
jmp 0x3ccdb
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x392b7(%rip), %rcx     # 0x75f5c
jmp 0x3cccd
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x392bb(%rip), %rcx     # 0x75f74
jmp 0x3cccd
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x393e6(%rip), %rcx     # 0x760b3
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x3ebc8
jmp 0x3cce0
// File: /workspace/github_c_makefile_star2_O1/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 0x3cd25
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x393ca(%rip), %rcx     # 0x760ea
jmp 0x3cdc2
movq %rdx, %r14
movq (%rdx), %rdi
leaq -0x24(%rbp), %r12
movq %r12, %rsi
callq 0x30b04
cmpl $0x0, (%r12)
jle 0x3cd9c
movq %rax, %r15
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3fd5f
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 0x3dde0
testq %rax, %rax
je 0x3cdcc
movq %rax, %r12
movq %rbx, %rdi
callq 0x317a5
testq %rax, %rax
je 0x3cdb0
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40ee1
movq 0x8(%rbx), %rsi
testl %eax, %eax
je 0x3cde4
movq %rsi, %rdi
jmp 0x3cdd0
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x391c6(%rip), %rcx     # 0x75f74
jmp 0x3cdc2
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x392f1(%rip), %rcx     # 0x760b3
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rdi
callq 0x309f2
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x3ebc8
jmp 0x3cdd5
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3d053
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3d067
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3d083
movq 0xa8(%rax), %rax
xorl %r15d, %r15d
subq $0x1, %rax
cmovaeq %rax, %r15
movl $0x2, %r14d
jmp 0x3d08c
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38ef7(%rip), %rcx     # 0x75f5c
jmp 0x3d079
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38efb(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl %r14d, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
jle 0x3d272
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3d286
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3d2a2
movq 0xb8(%rax), %r15
movl $0x2, %r14d
jmp 0x3d2ab
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38cd8(%rip), %rcx     # 0x75f5c
jmp 0x3d298
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38cdc(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r15, (%rbx)
movl $0xfffffe90, %eax       # imm = 0xFFFFFE90
andl 0x8(%rbx), %eax
orl %r14d, %eax
movl %eax, 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3d35b
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3d36f
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3d38b
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 0x3925a(%rip), %rsi     # 0x765a1
movq %rbx, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x45c53
addq $0x10, %rsp
jmp 0x3d3ac
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38bef(%rip), %rcx     # 0x75f5c
jmp 0x3d381
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38bf3(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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 0x3d3e7
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x391d7(%rip), %rcx     # 0x765b9
jmp 0x3d481
movq %rdx, %r14
movl %esi, %r15d
movq (%rdx), %rdi
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x30b04
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x3d46f
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3d4bc
movq %rax, %r12
movl %r15d, %r13d
movl $0x1, %r15d
movq (%r14,%r15,8), %rsi
testb $0x40, 0x8(%rsi)
je 0x3d453
movq (%rsi), %rdi
testb $0x1, 0x40(%rdi)
jne 0x3d453
leaq 0x8971(%rip), %rsi      # 0x45dba
movq %r12, %rdx
callq 0x52ab1
jmp 0x3d45b
movq %r12, %rdi
callq 0x45dc4
testl %eax, %eax
jne 0x3d4db
incq %r15
cmpq %r15, %r13
jne 0x3d42f
movl $0x1, %r14d
jmp 0x3d48e
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38af3(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%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 0x3911d(%rip), %rdx     # 0x765e0
xorl %r14d, %r14d
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x3d48e
leaq 0x39116(%rip), %rdx     # 0x765f8
xorl %r14d, %r14d
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x45d26
jmp 0x3d48e
// File: /workspace/github_c_makefile_star2_O1/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 0x3d86d
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38d51(%rip), %rcx     # 0x765b9
jmp 0x3d8f5
movq %rdx, %r14
movq (%rdx), %rdi
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x30b04
movl (%r15), %ecx
testl %ecx, %ecx
jle 0x3d8e3
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3d92d
movq %rax, %r15
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x3fd5f
movq (%r14), %rsi
movq %r15, %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x45ff2
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%rbx)
jmp 0x3d912
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x3867f(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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 0x38cac(%rip), %rdx     # 0x765e0
leaq -0x30(%rbp), %rcx
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x3d8ff
// File: /workspace/github_c_makefile_star2_O1/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 0x3d972
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38e0d(%rip), %rcx     # 0x7677d
jmp 0x3d99a
movq %rdx, %r14
movq 0x8(%rdx), %rax
testb $0x40, 0x8(%rax)
je 0x3d988
movq (%rax), %rax
testb $0x1, 0x40(%rax)
jne 0x3d9d1
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38e0c(%rip), %rcx     # 0x767a6
movl $0x1, %edx
callq 0x4153c
xorl %r14d, %r14d
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
movq %r14, (%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 0x30b04
movl (%r15), %ecx
testl %ecx, %ecx
jle 0x3da3c
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3da53
movq 0x8(%r14), %r8
testb $0x40, 0x8(%r8)
je 0x3d9a4
movq (%r8), %rcx
testb $0x1, 0x40(%rcx)
je 0x3d9a4
xorl %edi, %edi
movq %rax, %rsi
movq $-0x1, %rdx
movq $-0x1, %rcx
callq 0x3e465
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
jmp 0x3d9a7
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38526(%rip), %rcx     # 0x75f74
jmp 0x3d99a
leaq 0x38b86(%rip), %rdx     # 0x765e0
xorl %r14d, %r14d
leaq -0x30(%rbp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
jmp 0x3d9a7
// File: /workspace/github_c_makefile_star2_O1/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 0x3daca
movq (%rdx), %rdi
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x30b04
movl (%r14), %ecx
testl %ecx, %ecx
jle 0x3dade
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x3dde0
testq %rax, %rax
je 0x3db26
addq $0x20, %rax
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x3ebc8
jmp 0x3db1b
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38ca1(%rip), %rcx     # 0x7677d
jmp 0x3daf0
movq (%rbx), %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsi
leaq 0x38484(%rip), %rcx     # 0x75f74
movl $0x1, %edx
callq 0x4153c
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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 0x38ab3(%rip), %rdx     # 0x765e0
leaq -0x28(%rbp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x45d26
movq 0x8(%rbx), %rdi
callq 0x309f2
jmp 0x3db1b
// File: /workspace/github_c_makefile_star2_O1/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 0x32cfc
xorl %r14d, %r14d
testl %eax, %eax
sete %r14b
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x309f2
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_O1/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
subq $0x18, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq $0x0, -0x38(%rbp)
cmpl $0x0, 0xd8(%rdi)
je 0x3de6f
movq (%rax), %r12
movq %rax, -0x30(%rbp)
movl 0x8(%rax), %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x3e3b3
movl %eax, %r14d
movq 0xc8(%rbx), %rax
movl 0xdc(%rbx), %ecx
decl %ecx
andl %r14d, %ecx
movq (%rax,%rcx,8), %r15
testq %r15, %r15
je 0x3de66
cmpl 0x18(%r15), %r14d
jne 0x3de5d
movl 0x10(%r15), %edx
movl %r13d, %eax
subl %edx, %eax
jne 0x3de59
movq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0x34ebe
testl %eax, %eax
je 0x3de69
movq 0x130(%r15), %r15
jmp 0x3de37
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
jmp 0x3de72
xorl %r15d, %r15d
movq %r15, -0x38(%rbp)
testq %r15, %r15
jne 0x3de9a
movq (%rax), %rsi
movl 0x8(%rax), %edx
xorl %r15d, %r15d
leaq -0x38(%rbp), %r8
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x3deac
testl %eax, %eax
jne 0x3de9a
movq -0x38(%rbp), %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3e417
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 0x3e423
movl %eax, %esi
shll $0x5, %esi
movzbl (%rdi), %edx
addl %eax, %edx
addl %esi, %edx
incq %rdi
cmpq %rcx, %rdi
jae 0x3e41d
movl %edx, %eax
shll $0x5, %eax
movzbl (%rdi), %esi
addl %edx, %esi
addl %eax, %esi
incq %rdi
cmpq %rcx, %rdi
jae 0x3e421
movl %esi, %edx
shll $0x5, %edx
movzbl (%rdi), %eax
addl %esi, %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jb 0x3e3c5
jmp 0x3e423
movl $0x1505, %eax           # imm = 0x1505
retq
movl %edx, %eax
jmp 0x3e423
movl %esi, %eax
popq %rbp
retq