LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCursorSeek
static int lhCursorSeek(unqlite_kv_cursor *pCursor,const void *pKey,int nByte,int iPos)
{
	lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
	int rc;
	/* Perform a lookup */
	rc = lhRecordLookup((lhash_kv_engine *)pCur->pStore,pKey,nByte,&pCur->pCell);
	if( rc != UNQLITE_OK ){
		SXUNUSED(iPos);
		pCur->pCell = 0;
		pCur->iState = L_HASH_CURSOR_STATE_DONE;
		return rc;
	}
	pCur->iState = L_HASH_CURSOR_STATE_CELL;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r13
movq (%r13), %rax
movq (%rax), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *0x10(%rax)
testl %eax, %eax
je 0x36af7
movl %eax, %r12d
movq $0x0, 0x10(%rbx)
movl $0x3, %eax
movl %eax, 0x8(%rbx)
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl %r14d, -0x2c(%rbp)
movl %r14d, %esi
callq *0xc0(%r13)
movl %eax, %r14d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl 0x130(%r13), %edx
addl %ecx, %edx
andl %eax, %edx
movq 0x128(%r13), %rax
movq 0x120(%r13), %rsi
addq %rax, %rsi
addl %ecx, %eax
andl %r14d, %eax
cmpq %rsi, %rdx
cmovbq %rdx, %rax
movl $0xfffffffa, %r12d      # imm = 0xFFFFFFFA
cmpl $0x0, 0xe0(%r13)
je 0x36ad5
movq 0xd8(%r13), %rcx
movl 0xe4(%r13), %edx
decl %edx
andl %eax, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x36ad5
cmpq %rax, (%rcx)
je 0x36b72
movq 0x20(%rcx), %rcx
jmp 0x36b5e
movq 0x8(%rcx), %rsi
leaq -0x38(%rbp), %rcx
movq %r13, %rdi
xorl %edx, %edx
callq 0x3833b
testl %eax, %eax
jne 0x36ad2
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl %r14d, %ecx
callq 0x385ca
testq %rax, %rax
je 0x36ad5
movq %rax, 0x10(%rbx)
xorl %r12d, %r12d
movl $0x2, %eax
jmp 0x36ae2
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCursorFirst
static int lhCursorFirst(unqlite_kv_cursor *pCursor)
{
	lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
	lhash_kv_engine *pEngine = (lhash_kv_engine *)pCursor->pStore;
	int rc;
	if( pCur->is_first ){
		/* Read the database header first */
		rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,0);
		if( rc != UNQLITE_OK ){
			return rc;
		}
		pCur->is_first = 0;
	}
	/* Point to the first map record */
	pCur->pRec = pEngine->pFirst;
	/* Load the cells */
	rc = lhCursorNextPage(pCur);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $0x0, 0xc(%rdi)
je 0x36beb
movq (%r14), %rax
movq (%rax), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *0x10(%rax)
testl %eax, %eax
je 0x36be4
popq %rbx
popq %r14
popq %rbp
retq
movl $0x0, 0xc(%rbx)
movq 0xf0(%r14), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x39878
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCursorLast
static int lhCursorLast(unqlite_kv_cursor *pCursor)
{
	lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
	lhash_kv_engine *pEngine = (lhash_kv_engine *)pCursor->pStore;
	int rc;
	if( pCur->is_first ){
		/* Read the database header first */
		rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,0);
		if( rc != UNQLITE_OK ){
			return rc;
		}
		pCur->is_first = 0;
	}
	/* Point to the last map record */
	pCur->pRec = pEngine->pList;
	/* Load the cells */
	rc = lhCursorPrevPage(pCur);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $0x0, 0xc(%rdi)
je 0x36c35
movq (%r14), %rax
movq (%rax), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *0x10(%rax)
testl %eax, %eax
je 0x36c2e
popq %rbx
popq %r14
popq %rbp
retq
movl $0x0, 0xc(%rbx)
movq 0xe8(%r14), %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x39920
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCursorDelete
static int lhCursorDelete(unqlite_kv_cursor *pCursor)
{
	lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
	lhcell *pCell;
	int rc;
	if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
		/* Invalid state */
		return UNQLITE_INVALID;
	}
	/* Point to the target cell  */
	pCell = pCur->pCell;
	/* Point to the next entry */
	pCur->pCell = pCell->pNext;
	/* Perform the deletion */
	rc = lhRecordRemove(pCell);
	return rc;
}

// Assembly:
movl $0xfffffff7, %eax       # imm = 0xFFFFFFF7
cmpl $0x2, 0x8(%rdi)
jne 0x36dd0
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x36dd0
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x60(%rcx), %rax
movq %rax, 0x10(%rdi)
movq 0x18(%rcx), %r12
testq %r12, %r12
je 0x36dba
movq %rcx, -0x40(%rbp)
movq 0x20(%rcx), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %r12, %rsi
leaq -0x38(%rbp), %rdx
callq *0x10(%rax)
testl %eax, %eax
jne 0x36dc2
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
movzbl 0x7(%rax), %ecx
movq %rcx, -0x48(%rbp)
movzbl 0x6(%rax), %r15d
movzbl 0x5(%rax), %r13d
movzbl 0x4(%rax), %r14d
movzbl 0x3(%rax), %ebx
movzbl 0x2(%rax), %ecx
movq %rcx, -0x50(%rbp)
movzbl 0x1(%rax), %ecx
movq %rcx, -0x58(%rbp)
movzbl (%rax), %r12d
movq -0x30(%rbp), %rdi
callq 0x3981a
testl %eax, %eax
jne 0x36dc2
shll $0x8, %r15d
addq -0x48(%rbp), %r15
shll $0x10, %r13d
orq %r15, %r13
shll $0x18, %r14d
orq %r13, %r14
shlq $0x20, %rbx
orq %r14, %rbx
movq -0x50(%rbp), %rcx
shlq $0x28, %rcx
orq %rbx, %rcx
movq -0x58(%rbp), %rbx
shlq $0x30, %rbx
orq %rcx, %rbx
shlq $0x38, %r12
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rdi
callq *0x50(%rax)
orq %rbx, %r12
jne 0x36d09
movq -0x40(%rbp), %rcx
movq %rcx, %rdi
callq 0x39640
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCursorKey
static int lhCursorKey(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
	lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
	lhcell *pCell;
	int rc;
	if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
		/* Invalid state */
		return UNQLITE_INVALID;
	}
	/* Point to the target cell */
	pCell = pCur->pCell;
	if( SyBlobLength(&pCell->sKey) > 0 ){
		/* Consume the key directly */
		rc = xConsumer(SyBlobData(&pCell->sKey),SyBlobLength(&pCell->sKey),pUserData);
	}else{
		/* Very large key */
		rc = lhConsumeCellkey(pCell,xConsumer,pUserData,0);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, 0x8(%rdi)
jne 0x36e16
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x36e16
movq %rsi, %rax
movl 0x50(%rdi), %esi
testl %esi, %esi
je 0x36e1d
movq 0x48(%rdi), %rdi
popq %rbp
jmpq *%rax
movl $0xfffffff7, %eax       # imm = 0xFFFFFFF7
popq %rbp
retq
movq %rax, %rsi
xorl %ecx, %ecx
popq %rbp
jmp 0x39132
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhash_bin_hash
static sxu32 lhash_bin_hash(const void *pSrc,sxu32 nLen)
{
	register unsigned char *zIn = (unsigned char *)pSrc;
	unsigned char *zEnd;
	sxu32 nH = 5381;
	if( nLen > 2048 /* 2K */ ){
		nLen = 2048;
	}
	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:
movl $0x800, %ecx            # imm = 0x800
cmpl %ecx, %esi
cmovbl %esi, %ecx
testl %esi, %esi
je 0x36ee1
pushq %rbp
movq %rsp, %rbp
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 0x36eed
movl %eax, %esi
shll $0x5, %esi
movzbl (%rdi), %edx
addl %eax, %edx
addl %esi, %edx
incq %rdi
cmpq %rcx, %rdi
jae 0x36ee7
movl %edx, %eax
shll $0x5, %eax
movzbl (%rdi), %esi
addl %edx, %esi
addl %eax, %esi
incq %rdi
cmpq %rcx, %rdi
jae 0x36eeb
movl %esi, %edx
shll $0x5, %edx
movzbl (%rdi), %eax
addl %esi, %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jb 0x36e8f
jmp 0x36eed
movl $0x1505, %eax           # imm = 0x1505
retq
movl %edx, %eax
jmp 0x36eed
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhash_page_release
static void lhash_page_release(void *pUserData)
{
	lhpage *pPage = (lhpage *)pUserData;
	lhash_kv_engine *pEngine = pPage->pHash;
	lhcell *pNext,*pCell = pPage->pList;
	unqlite_page *pRaw = pPage->pRaw;
	sxu32 n;
	/* Drop in-memory cells */
	for( n = 0 ; n < pPage->nCell ; ++n ){
		pNext = pCell->pNext;
		SyBlobRelease(&pCell->sKey);
		/* Release the cell instance */
		SyMemBackendPoolFree(&pEngine->sAllocator,(void *)pCell);
		/* Point to the next entry */
		pCell = pNext;
	}
	if( pPage->apCell ){
		/* Release the cell table */
		SyMemBackendFree(&pEngine->sAllocator,(void *)pPage->apCell);
	}
	/* Finally, release the whole page */
	SyMemBackendPoolFree(&pEngine->sAllocator,pPage);
	pRaw->pUserData = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x38(%rdi)
je 0x36f4d
movq 0x28(%rbx), %r12
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r15
xorl %r13d, %r13d
movq 0x60(%r12), %r14
leaq 0x40(%r12), %rdi
callq 0x317be
movq %r15, %rdi
movq %r12, %rsi
callq 0x2e659
incl %r13d
movq %r14, %r12
cmpl 0x38(%rbx), %r13d
jb 0x36f27
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
movq -0x30(%rbp), %r14
je 0x36f63
leaq 0x8(%r14), %rdi
callq 0x3490d
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e659
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhMapLoadPage
static int lhMapLoadPage(lhash_kv_engine *pEngine,lhash_bmap_page *pMap,const unsigned char *zRaw)
{
	const unsigned char *zEnd = &zRaw[pEngine->iPageSize];
	const unsigned char *zPtr = zRaw;
	pgno iLogic,iReal;
	sxu32 n;
	int rc;
	if( pMap->iPtr == 0 ){
		/* Read the map header */
		SyBigEndianUnpack64(zRaw,&pMap->iNext);
		zRaw += 8;
		SyBigEndianUnpack32(zRaw,&pMap->nRec);
		zRaw += 4;
	}else{
		/* Mostly page one of the database */
		zRaw += pMap->iPtr;
	}
	/* Start processing */
	for( n = 0; n < pMap->nRec ; ++n ){
		if( zRaw >= zEnd ){
			break;
		}
		/* Extract the logical and real bucket number */
		SyBigEndianUnpack64(zRaw,&iLogic);
		zRaw += 8;
		SyBigEndianUnpack64(zRaw,&iReal);
		zRaw += 8;
		/* Install the record in the map */
		rc = lhMapInstallBucket(pEngine,iLogic,iReal);
		if( rc != UNQLITE_OK ){
			return rc;
		}
	}
	pMap->iPtr = (sxu16)(zRaw-zPtr);
	/* All done */
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movslq 0x110(%rdi), %r13
movzwl 0x8(%rsi), %r12d
testq %r12, %r12
je 0x36fcc
addq %r14, %r12
movl 0xc(%rbx), %eax
jmp 0x36fe5
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x36f8d
movl 0x8(%r14), %eax
bswapl %eax
movl %eax, 0xc(%rbx)
leaq 0xc(%r14), %r12
testl %eax, %eax
movq %r14, -0x30(%rbp)
je 0x37028
addq %r14, %r13
cmpq %r13, %r12
jae 0x37028
movl $0x1, %r14d
movq (%r12), %rsi
movq 0x8(%r12), %rdx
bswapq %rsi
bswapq %rdx
movq %r15, %rdi
callq 0x37049
testl %eax, %eax
jne 0x37035
addq $0x10, %r12
cmpl 0xc(%rbx), %r14d
jae 0x37028
incl %r14d
cmpq %r13, %r12
jb 0x36ffb
subl -0x30(%rbp), %r12d
movw %r12w, 0x8(%rbx)
xorl %eax, %eax
jmp 0x3703a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhAcquirePage
static int lhAcquirePage(lhash_kv_engine *pEngine,unqlite_page **ppOut)
{
	unqlite_page *pPage;
	int rc;
	if( pEngine->nFreeList != 0 ){
		/* Acquire one from the free list */
		rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pEngine->nFreeList,&pPage);
		if( rc == UNQLITE_OK ){
			/* Point to the next free page */
			SyBigEndianUnpack64(pPage->zData,&pEngine->nFreeList);
			/* Update the database header */
			rc = pEngine->pIo->xWrite(pEngine->pHeader);
			if( rc != UNQLITE_OK ){
				return rc;
			}
			SyBigEndianPack64(&pEngine->pHeader->zData[4/*Magic*/+4/*Hash*/],pEngine->nFreeList);
			/* Tell the pager do not journal this page */
			pEngine->pIo->xDontJournal(pPage);
			/* Return to the caller */
			*ppOut = pPage;
			/* All done */
			return UNQLITE_OK;
		}
	}
	/* Acquire a new page */
	rc = pEngine->pIo->xNew(pEngine->pIo->pHandle,&pPage);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	/* Point to the target page */
	*ppOut = pPage;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x118(%rdi), %rsi
testq %rsi, %rsi
je 0x37e0a
movq (%r14), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rdx
callq *0x10(%rax)
testl %eax, %eax
je 0x37e1d
movq (%r14), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
callq *0x20(%rax)
testl %eax, %eax
jne 0x37e6c
jmp 0x37e63
leaq 0x118(%r14), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x36f8d
movq (%r14), %rax
movq 0xd0(%r14), %rdi
callq *0x28(%rax)
testl %eax, %eax
jne 0x37e6c
movq 0xd0(%r14), %rax
movq 0x118(%r14), %rcx
bswapq %rcx
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq (%r14), %rax
movq -0x18(%rbp), %rdi
callq *0x38(%rax)
movq -0x18(%rbp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhNewPage
static lhpage * lhNewPage(
	lhash_kv_engine *pEngine, /* KV store which own this instance */
	unqlite_page *pRaw,       /* Raw page contents */
	lhpage *pMaster           /* Master page in case we are dealing with a slave page */
	)
{
	lhpage *pPage;
	/* Allocate a new instance */
	pPage = (lhpage *)SyMemBackendPoolAlloc(&pEngine->sAllocator,sizeof(lhpage));
	if( pPage == 0 ){
		return 0;
	}
	/* Zero the structure */
	SyZero(pPage,sizeof(lhpage));
	/* Fill-in the structure */
	pPage->pHash = pEngine;
	pPage->pRaw = pRaw;
	pPage->pMaster = pMaster ? pMaster /* Slave page */ : pPage /* Master page */ ;
	if( pPage->pMaster != pPage ){
		/* Slave page, attach it to its master */
		pPage->pNextSlave = pMaster->pSlave;
		pMaster->pSlave = pPage;
		pMaster->iSlave++;
	}
	/* Save this instance for future fast lookup */
	pRaw->pUserData = pPage;
	/* All done */
	return pPage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
addq $0x8, %rdi
movl $0x60, %esi
callq 0x2e481
testq %rax, %rax
je 0x37ee2
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x5c, %rcx
jb 0x37ea2
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
testq %r14, %r14
movq %r14, %rcx
cmoveq %rax, %rcx
movq %rcx, 0x40(%rax)
cmpq %rax, %rcx
je 0x37ede
movq 0x48(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x48(%r14)
incl 0x58(%r14)
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhSetEmptyPage
static int lhSetEmptyPage(lhpage *pPage)
{
	unsigned char *zRaw = pPage->pRaw->zData;
	lhphdr *pHeader = &pPage->sHdr;
	sxu16 nByte;
	int rc;
	/* Acquire a writer lock */
	rc = pPage->pHash->pIo->xWrite(pPage->pRaw);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	/* Offset of the first cell */
	SyBigEndianPack16(zRaw,0);
	zRaw += 2;
	/* Offset of the first free block */
	pHeader->iFree = L_HASH_PAGE_HDR_SZ;
	SyBigEndianPack16(zRaw,L_HASH_PAGE_HDR_SZ);
	zRaw += 2;
	/* Slave page number */
	SyBigEndianPack64(zRaw,0);
	zRaw += 8;
	/* Fill the free block */
	SyBigEndianPack16(zRaw,0); /* Offset of the next free block */
	zRaw += 2;
	nByte = (sxu16)L_HASH_MX_FREE_SPACE(pPage->pHash->iPageSize);
	SyBigEndianPack16(zRaw,nByte);
	pPage->nFree = nByte;
	/* Do not add this page to the hot dirty list */
	pPage->pHash->pIo->xDontMkHot(pPage->pRaw);
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq (%rdi), %r15
movq (%rax), %rax
callq *0x28(%rax)
movl %eax, %r14d
testl %eax, %eax
jne 0x37f59
xorl %eax, %eax
movw %ax, (%r15)
movw $0xc, 0x12(%rbx)
movw $0xc00, 0x2(%r15)       # imm = 0xC00
movw %ax, 0xc(%r15)
movq $0x0, 0x4(%r15)
movq (%rbx), %rax
movl 0x110(%rax), %eax
addl $-0xc, %eax
movl %eax, %ecx
rolw $0x8, %cx
movw %cx, 0xe(%r15)
movw %ax, 0x5c(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq (%rax), %rax
callq *0x40(%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhFindCell
static lhcell * lhFindCell(
	lhpage *pPage,    /* Target page */
	const void *pKey, /* Lookup key */
	sxu32 nByte,      /* Key length */
	sxu32 nHash       /* Hash of the key */
	)
{
	lhcell *pEntry;
	if( pPage->nCell < 1 ){
		/* Don't bother hashing */
		return 0;
	}
	/* Point to the corresponding bucket */
	pEntry = pPage->apCell[nHash & (pPage->nCellSize - 1)];
	for(;;){
		if( pEntry == 0 ){
			break;
		}
		if( pEntry->nHash == nHash && pEntry->nKey == nByte ){
			if( SyBlobLength(&pEntry->sKey) < 1 ){
				/* Large key (> 256 KB) are not kept in-memory */
				struct lhash_key_cmp sCmp;
				int rc;
				/* Fill-in the structure */
				sCmp.zIn = (const char *)pKey;
				sCmp.zEnd = &sCmp.zIn[nByte];
				sCmp.xCmp = pPage->pHash->xCmp;
				/* Fetch the key from disk and perform the comparison */
				rc = lhConsumeCellkey(pEntry,lhKeyCmp,&sCmp,0);
				if( rc == UNQLITE_OK ){
					/* Cell found */
					return pEntry;
				}
			}else if ( pPage->pHash->xCmp(pKey,SyBlobData(&pEntry->sKey),nByte) == 0 ){
				/* Cell found */
				return pEntry;
			}
		}
		/* Point to the next entry */
		pEntry = pEntry->pNextCol;
	}
	/* No such entry */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x38(%rdi)
je 0x38673
movl %ecx, %r14d
movq %rdi, %r13
movq 0x20(%rdi), %rax
movl 0x3c(%rdi), %ecx
decl %ecx
andl %r14d, %ecx
movq (%rax,%rcx,8), %rbx
testq %rbx, %rbx
je 0x38673
movl %edx, %r15d
movq %rsi, %r12
movl %edx, %eax
addq %rsi, %rax
movq %rax, -0x30(%rbp)
cmpl %r14d, (%rbx)
jne 0x3866a
cmpl %r15d, 0x4(%rbx)
jne 0x3866a
cmpl $0x0, 0x50(%rbx)
je 0x38636
movq (%r13), %rax
movq 0x48(%rbx), %rsi
movq %r12, %rdi
movl %r15d, %edx
callq *0xc8(%rax)
jmp 0x38666
movq %r12, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%r13), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
leaq 0xc4b(%rip), %rsi       # 0x392a6
leaq -0x48(%rbp), %rdx
xorl %ecx, %ecx
callq 0x39132
testl %eax, %eax
je 0x38675
movq 0x70(%rbx), %rbx
testq %rbx, %rbx
jne 0x3860f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhNewCell
static lhcell * lhNewCell(lhash_kv_engine *pEngine,lhpage *pPage)
{
	lhcell *pCell;
	pCell = (lhcell *)SyMemBackendPoolAlloc(&pEngine->sAllocator,sizeof(lhcell));
	if( pCell == 0 ){
		return 0;
	}
	/* Zero the structure */
	SyZero(pCell,sizeof(lhcell));
	/* Fill in the structure */
	SyBlobInit(&pCell->sKey,&pEngine->sAllocator);
	pCell->pPage = pPage;
	return pCell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
movq %r14, %rdi
movl $0x80, %esi
callq 0x2e481
testq %rax, %rax
je 0x389d3
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x7c, %rcx
jb 0x389ab
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movq %r14, 0x40(%rax)
movl $0x0, 0x58(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCellDiscard
static void lhCellDiscard(lhcell *pCell)
{
	lhpage *pPage = pCell->pPage->pMaster;	
	
	if( pCell->pPrevCol ){
		pCell->pPrevCol->pNextCol = pCell->pNextCol;
	}else{
		pPage->apCell[pCell->nHash & (pPage->nCellSize - 1)] = pCell->pNextCol;
	}
	if( pCell->pNextCol ){
		pCell->pNextCol->pPrevCol = pCell->pPrevCol;
	}
	MACRO_LD_REMOVE(pPage->pList,pCell);
	if( pCell == pPage->pFirst ){
		pPage->pFirst = pCell->pPrev;
	}
	pPage->nCell--;
	/* Release the cell */
	SyBlobRelease(&pCell->sKey);
	SyMemBackendPoolFree(&pPage->pHash->sAllocator,pCell);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
movq 0x70(%rdi), %rax
movq 0x40(%rcx), %r14
movq 0x78(%rdi), %rcx
testq %rcx, %rcx
je 0x38ee2
addq $0x70, %rcx
jmp 0x38ef2
movl 0x3c(%r14), %ecx
decl %ecx
andl (%rbx), %ecx
shlq $0x3, %rcx
addq 0x20(%r14), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0x38f02
movq 0x78(%rbx), %rcx
movq %rcx, 0x78(%rax)
movq 0x28(%r14), %rax
cmpq %rbx, %rax
jne 0x38f13
movq 0x60(%rax), %rax
movq %rax, 0x28(%r14)
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
testq %rcx, %rcx
je 0x38f24
movq %rax, 0x60(%rcx)
testq %rax, %rax
je 0x38f2d
movq %rcx, 0x68(%rax)
cmpq %rbx, 0x30(%r14)
jne 0x38f3b
movq 0x68(%rbx), %rax
movq %rax, 0x30(%r14)
decl 0x38(%r14)
leaq 0x40(%rbx), %rdi
callq 0x317be
movq (%r14), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e659
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhKeyCmp
static int lhKeyCmp(const void *pData,sxu32 nLen,void *pUserData)
{
	struct lhash_key_cmp *pCmp = (struct lhash_key_cmp *)pUserData;
	int rc;
	if( pCmp->zIn >= pCmp->zEnd ){
		if( nLen > 0 ){
			return UNQLITE_ABORT;
		}
		return UNQLITE_OK;
	}
	/* Perform the comparison */
	rc = pCmp->xCmp((const void *)pCmp->zIn,pData,nLen);
	if( rc != 0 ){
		/* Abort comparison */
		return UNQLITE_ABORT;
	}
	/* Advance the cursor */
	pCmp->zIn += nLen;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %rsi
movq (%rdx), %rdi
cmpq 0x8(%rdx), %rdi
jae 0x392d8
movq %rdx, %r14
movl %ebx, %edx
callq *0x10(%r14)
movl %eax, %ecx
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
testl %ecx, %ecx
jne 0x392e2
movl %ebx, %eax
addq %rax, (%r14)
xorl %eax, %eax
jmp 0x392e2
testl %ebx, %ebx
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
cmovel %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhUnlinkCell
static int lhUnlinkCell(lhcell *pCell)
{
	lhash_kv_engine *pEngine = pCell->pPage->pHash;
	lhpage *pPage = pCell->pPage;
	sxu16 nByte = L_HASH_CELL_SZ;
	lhcell *pPrev;
	int rc;
	rc = pEngine->pIo->xWrite(pPage->pRaw);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	/* Bring the link */
	pPrev = lhFindSibeling(pCell);
	if( pPrev ){
		pPrev->iNext = pCell->iNext;
		/* Fix offsets in the page header */
		SyBigEndianPack16(&pPage->pRaw->zData[pPrev->iStart + 4/*Hash*/+4/*Key*/+8/*Data*/],pCell->iNext);
	}else{
		/* First entry on this page (either master or slave) */
		pPage->sHdr.iOfft = pCell->iNext;
		/* Update the page header */
		SyBigEndianPack16(pPage->pRaw->zData,pCell->iNext);
	}
	/* Restore cell space */
	if( pCell->iOvfl == 0 ){
		nByte += (sxu16)(pCell->nData + pCell->nKey);
	}
	lhRestoreSpace(pPage,pCell->iStart,nByte);
	/* Discard the cell from the in-memory hashtable */
	lhCellDiscard(pCell);
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq (%r14), %rax
movq 0x8(%r14), %rdi
movq (%rax), %rax
callq *0x28(%rax)
testl %eax, %eax
jne 0x396ca
movq 0x20(%rbx), %rcx
movq 0x40(%rcx), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x39686
cmpq %rcx, 0x20(%rax)
jne 0x39680
movzwl 0x10(%rax), %edx
cmpw 0x28(%rbx), %dx
je 0x396cf
movq 0x68(%rax), %rax
jmp 0x3966b
movzwl 0x10(%rbx), %ecx
movw %cx, 0x10(%r14)
movq 0x8(%r14), %rax
movq (%rax), %rax
movb %cl, 0x1(%rax)
movb %ch, (%rax)
movw $0x1a, %ax
cmpq $0x0, 0x18(%rbx)
jne 0x396b1
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %ecx
addl %ecx, %eax
addl $0x1a, %eax
movzwl 0x28(%rbx), %esi
movzwl %ax, %edx
movq %r14, %rdi
callq 0x396eb
movq %rbx, %rdi
callq 0x38ebd
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movzwl 0x10(%rbx), %ecx
movw %cx, 0x10(%rax)
movq 0x8(%r14), %rdx
movq (%rdx), %rdx
movzwl 0x28(%rax), %eax
addq %rdx, %rax
addq $0x10, %rax
jmp 0x39696
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhMoveLocalCell
static int lhMoveLocalCell(
	lhcell *pCell,
	sxu16 iOfft,
	const void *pData,
	unqlite_int64 nData
	)
{
	sxu16 iKeyOfft = pCell->iStart + L_HASH_CELL_SZ;
	lhpage *pPage = pCell->pPage;
	lhcell *pSibeling;
	pSibeling = lhFindSibeling(pCell);
	if( pSibeling ){
		/* Fix link */
		SyBigEndianPack16(&pPage->pRaw->zData[pSibeling->iStart + 4/*Hash*/+4/*Key*/+8/*Data*/],pCell->iNext);
		pSibeling->iNext = pCell->iNext;
	}else{
		/* First cell, update page header only */
		SyBigEndianPack16(pPage->pRaw->zData,pCell->iNext);
		pPage->sHdr.iOfft = pCell->iNext;
	}
	/* Set the new offset */
	pCell->iStart = iOfft;
	pCell->nData = (sxu64)nData;
	/* Write the cell payload */
	lhCellWriteLocalPayload(pCell,(const void *)&pPage->pRaw->zData[iKeyOfft],pCell->nKey,pData,nData);
	/* Finally write the cell header */
	lhCellWriteHeader(pCell);
	/* All done */
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movzwl 0x28(%rdi), %eax
movq 0x20(%rdi), %rcx
movq 0x40(%rcx), %rdx
movq 0x30(%rdx), %rdx
testq %rdx, %rdx
je 0x39771
cmpq %rcx, 0x20(%rdx)
jne 0x3976b
cmpw %ax, 0x10(%rdx)
je 0x397f1
movq 0x68(%rdx), %rdx
jmp 0x39756
movq 0x8(%rcx), %rdx
movzwl 0x10(%rbx), %edi
rolw $0x8, %di
movq (%rdx), %rdx
movw %di, (%rdx)
movzwl 0x10(%rbx), %edx
movw %dx, 0x10(%rcx)
addl $0x1a, %eax
movw %si, 0x28(%rbx)
movq %r14, 0x8(%rbx)
movq 0x8(%rcx), %rcx
movzwl %ax, %edi
addq (%rcx), %rdi
movl 0x4(%rbx), %r12d
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movzwl %si, %ecx
leaq (%rax,%rcx), %r13
addq $0x1a, %r13
movq %r13, %rsi
movl %r12d, %edx
callq 0x34893
testq %r14, %r14
jle 0x397db
addq %r12, %r13
movq %r15, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x34893
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x38f5b
movq 0x8(%rcx), %rdi
movq (%rdi), %rdi
movzwl 0x10(%rbx), %r8d
rolw $0x8, %r8w
movzwl 0x28(%rdx), %r9d
movw %r8w, 0x10(%rdi,%r9)
movzwl 0x10(%rbx), %edi
movw %di, 0x10(%rdx)
jmp 0x3978b
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCursorNextPage
static int lhCursorNextPage(lhash_kv_cursor *pPtr)
{
	lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
	lhash_bmap_rec *pRec;
	lhpage *pPage;
	int rc;
	for(;;){
		pRec = pCur->pRec;
		if( pRec == 0 ){
			pCur->iState = L_HASH_CURSOR_STATE_DONE;
			return UNQLITE_DONE;
		}
		if( pPtr->iState == L_HASH_CURSOR_STATE_CELL && pPtr->pRaw ){
			/* Unref this page */
			pCur->pStore->pIo->xPageUnref(pPtr->pRaw);
			pPtr->pRaw = 0;
		}
		/* Advance the map cursor */
		pCur->pRec = pRec->pPrev; /* Not a bug, reverse link */
		/* Load the next page on the list */
		rc = lhLoadPage((lhash_kv_engine *)pCur->pStore,pRec->iReal,0,&pPage,0);
		if( rc != UNQLITE_OK ){
			return rc;
		}
		if( pPage->pList ){
			/* Reflect the change */
			pCur->pCell = pPage->pList;
			pCur->iState = L_HASH_CURSOR_STATE_CELL;
			pCur->pRaw = pPage->pRaw;
			break;
		}
		/* Empty page, discard this page and continue */
		pPage->pHash->pIo->xPageUnref(pPage->pRaw);
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x398f2
leaq -0x20(%rbp), %r14
cmpl $0x2, 0x8(%rbx)
jne 0x398b2
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x398b2
movq (%rbx), %rax
movq (%rax), %rax
callq *0x50(%rax)
movq $0x0, 0x18(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x20(%rbx)
movq (%rbx), %rdi
movq 0x8(%r15), %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x3833b
testl %eax, %eax
jne 0x39915
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
testq %rcx, %rcx
jne 0x39900
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movq (%rcx), %rax
callq *0x50(%rax)
movq 0x20(%rbx), %r15
testq %r15, %r15
jne 0x39892
movl $0x3, 0x8(%rbx)
movl $0xffffffe4, %eax       # imm = 0xFFFFFFE4
jmp 0x39915
movq %rcx, 0x10(%rbx)
movl $0x2, 0x8(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCursorPrevPage
static int lhCursorPrevPage(lhash_kv_cursor *pPtr)
{
	lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
	lhash_bmap_rec *pRec;
	lhpage *pPage;
	int rc;
	for(;;){
		pRec = pCur->pRec;
		if( pRec == 0 ){
			pCur->iState = L_HASH_CURSOR_STATE_DONE;
			return UNQLITE_DONE;
		}
		if( pPtr->iState == L_HASH_CURSOR_STATE_CELL && pPtr->pRaw ){
			/* Unref this page */
			pCur->pStore->pIo->xPageUnref(pPtr->pRaw);
			pPtr->pRaw = 0;
		}
		/* Advance the map cursor */
		pCur->pRec = pRec->pNext; /* Not a bug, reverse link */
		/* Load the previous page on the list */
		rc = lhLoadPage((lhash_kv_engine *)pCur->pStore,pRec->iReal,0,&pPage,0);
		if( rc != UNQLITE_OK ){
			return rc;
		}
		if( pPage->pFirst ){
			/* Reflect the change */
			pCur->pCell = pPage->pFirst;
			pCur->iState = L_HASH_CURSOR_STATE_CELL;
			pCur->pRaw = pPage->pRaw;
			break;
		}
		/* Discard this page and continue */
		pPage->pHash->pIo->xPageUnref(pPage->pRaw);
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x3999a
leaq -0x20(%rbp), %r14
cmpl $0x2, 0x8(%rbx)
jne 0x3995a
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3995a
movq (%rbx), %rax
movq (%rax), %rax
callq *0x50(%rax)
movq $0x0, 0x18(%rbx)
movq 0x10(%r15), %rax
movq %rax, 0x20(%rbx)
movq (%rbx), %rdi
movq 0x8(%r15), %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x3833b
testl %eax, %eax
jne 0x399bd
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
testq %rcx, %rcx
jne 0x399a8
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movq (%rcx), %rax
callq *0x50(%rax)
movq 0x20(%rbx), %r15
testq %r15, %r15
jne 0x3993a
movl $0x3, 0x8(%rbx)
movl $0xffffffe4, %eax       # imm = 0xFFFFFFE4
jmp 0x399bd
movq %rcx, 0x10(%rbx)
movl $0x2, 0x8(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SySetRelease
JX9_PRIVATE sxi32 SySetRelease(SySet *pSet)
{
	sxi32 rc = SXRET_OK;
	if( pSet->pAllocator && pSet->pBase ){
		rc = SyMemBackendFree(pSet->pAllocator, pSet->pBase);
	}
	pSet->pBase = 0;
	pSet->nUsed = 0;
	pSet->nCursor = 0;
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x399e7
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x399e7
callq 0x3490d
movq $0x0, 0x8(%rbx)
xorl %eax, %eax
movl %eax, 0x10(%rbx)
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: EngineRelease
static sxi32 EngineRelease(jx9 *pEngine)
{
	jx9_vm *pVm, *pNext;
	/* Release all active VM */
	pVm = pEngine->pVms;
	for(;;){
		if( pEngine->iVm < 1 ){
			break;
		}
		pNext = pVm->pNext;
		jx9VmRelease(pVm);
		pVm = pNext;
		pEngine->iVm--;
	}
	/* Set a dummy magic number */
	pEngine->nMagic = 0x7635;
	/* Release the private memory subsystem */
	SyMemBackendRelease(&pEngine->sAllocator); 
	return JX9_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x100(%rdi)
jle 0x39a45
movq 0xf8(%rbx), %rdi
movq 0x6d8(%rdi), %r14
movl $0xdead2bad, 0x6e8(%rdi) # imm = 0xDEAD2BAD
callq 0x2e588
movl 0x100(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x100(%rbx)
movq %r14, %rdi
cmpl $0x1, %eax
jg 0x39a18
movl $0x7635, 0x118(%rbx)    # imm = 0x7635
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e588
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteFindKVStore
UNQLITE_PRIVATE unqlite_kv_methods * unqliteFindKVStore(
	const char *zName, /* Storage engine name [i.e. Hash, B+tree, LSM, etc.] */
	sxu32 nByte /* zName length */
	)
{
	unqlite_kv_methods **apStore,*pEntry;
	sxu32 n,nMax;
	/* Point to the set of installed engines */
	apStore = (unqlite_kv_methods **)SySetBasePtr(&sUnqlMPGlobal.kv_storage);
	nMax = SySetUsed(&sUnqlMPGlobal.kv_storage);
	for( n = 0 ; n < nMax; ++n ){
		pEntry = apStore[n];
		if( nByte == SyStrlen(pEntry->zName) && SyStrnicmp(pEntry->zName,zName,nByte) == 0 ){
			/* Storage engine found */
			return pEntry;
		}
	}
	/* No such entry, return NULL */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movl 0x5ad2c(%rip), %r12d    # 0x947a0
testq %r12, %r12
je 0x39ae5
movl %esi, %ebx
movq 0x5ad16(%rip), %r13     # 0x94798
xorl %r14d, %r14d
movq (%r13,%r14,8), %r15
movq (%r15), %rdi
cmpb $0x0, (%rdi)
movq %rdi, %rax
je 0x39ac8
leaq 0x2(%rdi), %rax
cmpb $0x0, -0x1(%rax)
je 0x39ac0
cmpb $0x0, (%rax)
je 0x39ac8
cmpb $0x0, 0x1(%rax)
je 0x39ac5
leaq 0x4(%rax), %rcx
cmpb $0x0, 0x2(%rax)
movq %rcx, %rax
jne 0x39a99
addq $-0x2, %rcx
movq %rcx, %rax
jmp 0x39ac8
decq %rax
jmp 0x39ac8
incq %rax
subl %edi, %eax
cmpl %ebx, %eax
jne 0x39add
movq -0x30(%rbp), %rsi
movl %ebx, %edx
callq 0x39f3f
testl %eax, %eax
je 0x39ae8
incq %r14
cmpq %r12, %r14
jne 0x39a85
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyRandomnessInit
JX9_PRIVATE sxi32 SyRandomnessInit(SyPRNGCtx *pCtx, ProcRandomSeed xSeed, void * pUserData)
{
	char zSeed[256];
	sxu8 t;
	sxi32 rc;
	sxu32 i;
	if( pCtx->nMagic == SXPRNG_MAGIC ){
		return SXRET_OK; /* Already initialized */
	}
 /* Initialize the state of the random number generator once, 
  ** the first time this routine is called.The seed value does
  ** not need to contain a lot of randomness since we are not
  ** trying to do secure encryption or anything like that...
  */	
	if( xSeed == 0 ){
		xSeed = SyOSUtilRandomSeed;
	}
	rc = xSeed(zSeed, sizeof(zSeed), pUserData);
	if( rc != SXRET_OK ){
		return rc;
	}
	pCtx->i = pCtx->j = 0;
	for(i=0; i < SX_ARRAYSIZE(pCtx->s) ; i++){
		pCtx->s[i] = (unsigned char)i;
    }
    for(i=0; i < sizeof(zSeed) ; i++){
      pCtx->j += pCtx->s[i] + zSeed[i];
      t = pCtx->s[pCtx->j];
      pCtx->s[pCtx->j] = pCtx->s[i];
      pCtx->s[i] = t;
    }
	pCtx->nMagic = SXPRNG_MAGIC;
	
	return SXRET_OK;
}

// Assembly:
cmpw $0x13c4, 0x102(%rdi)    # imm = 0x13C4
je 0x39bc9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0x39e73(%rip), %rdi     # 0x73992
xorl %esi, %esi
xorl %eax, %eax
callq 0xc510
testl %eax, %eax
js 0x39b44
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
movl %eax, %edi
callq 0xc890
testq %rax, %rax
jg 0x39b6e
callq 0xcc70
leaq -0xc(%rbp), %rdi
movl %eax, (%rdi)
leaq -0x110(%rbp), %rsi
movl $0x4, %edx
callq 0x34893
leaq -0x10c(%rbp), %rdi
xorl %esi, %esi
callq 0xc5a0
movb $0x0, (%rbx)
xorl %eax, %eax
movb %al, 0x2(%rbx,%rax)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x39b73
xorl %eax, %eax
xorl %ecx, %ecx
movb 0x2(%rbx,%rax), %dl
movb -0x110(%rbp,%rax), %sil
addb %dl, %sil
addb %sil, %cl
movzbl %cl, %esi
movb 0x2(%rbx,%rsi), %dil
movb %dl, 0x2(%rbx,%rsi)
movb %dil, 0x2(%rbx,%rax)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x39b86
movb %cl, 0x1(%rbx)
movw $0x13c4, 0x102(%rbx)    # imm = 0x13C4
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyRandomness
JX9_PRIVATE sxi32 SyRandomness(SyPRNGCtx *pCtx, void *pBuf, sxu32 nLen)
{
	unsigned char *zBuf = (unsigned char *)pBuf;
	unsigned char *zEnd = &zBuf[nLen];
#if defined(UNTRUST)
	if( pCtx == 0 || pBuf == 0 || nLen <= 0 ){
		return SXERR_EMPTY;
	}
#endif
	if(pCtx->nMagic != SXPRNG_MAGIC ){
		return SXERR_CORRUPT;
	}
	for(;;){
		if( zBuf >= zEnd ){break;}	zBuf[0] = randomByte(pCtx);	zBuf++;	
		if( zBuf >= zEnd ){break;}	zBuf[0] = randomByte(pCtx);	zBuf++;	
		if( zBuf >= zEnd ){break;}	zBuf[0] = randomByte(pCtx);	zBuf++;	
		if( zBuf >= zEnd ){break;}	zBuf[0] = randomByte(pCtx);	zBuf++;	
	}
	return SXRET_OK;  
}

// Assembly:
cmpw $0x13c4, 0x102(%rdi)    # imm = 0x13C4
setne %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x39cf9
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
addq %rsi, %rax
movb (%rdi), %cl
incb %cl
movb %cl, (%rdi)
movzbl %cl, %ecx
movb 0x2(%rdi,%rcx), %dl
movb 0x1(%rdi), %r8b
addb %dl, %r8b
movb %r8b, 0x1(%rdi)
movzbl %r8b, %r8d
movb 0x2(%rdi,%r8), %r9b
movb %r9b, 0x2(%rdi,%rcx)
movb %dl, 0x2(%rdi,%r8)
addb 0x2(%rdi,%rcx), %dl
movzbl %dl, %ecx
movb 0x2(%rdi,%rcx), %cl
movb %cl, (%rsi)
incq %rsi
cmpq %rax, %rsi
jae 0x39cf8
movb (%rdi), %cl
incb %cl
movb %cl, (%rdi)
movzbl %cl, %ecx
movb 0x2(%rdi,%rcx), %dl
movb 0x1(%rdi), %r8b
addb %dl, %r8b
movb %r8b, 0x1(%rdi)
movzbl %r8b, %r8d
movb 0x2(%rdi,%r8), %r9b
movb %r9b, 0x2(%rdi,%rcx)
movb %dl, 0x2(%rdi,%r8)
addb 0x2(%rdi,%rcx), %dl
movzbl %dl, %ecx
movb 0x2(%rdi,%rcx), %cl
movb %cl, (%rsi)
incq %rsi
cmpq %rax, %rsi
jae 0x39cf8
movb (%rdi), %cl
incb %cl
movb %cl, (%rdi)
movzbl %cl, %ecx
movb 0x2(%rdi,%rcx), %dl
movb 0x1(%rdi), %r8b
addb %dl, %r8b
movb %r8b, 0x1(%rdi)
movzbl %r8b, %r8d
movb 0x2(%rdi,%r8), %r9b
movb %r9b, 0x2(%rdi,%rcx)
movb %dl, 0x2(%rdi,%r8)
addb 0x2(%rdi,%rcx), %dl
movzbl %dl, %ecx
movb 0x2(%rdi,%rcx), %cl
movb %cl, (%rsi)
incq %rsi
cmpq %rax, %rsi
jae 0x39cf8
movb (%rdi), %cl
incb %cl
movb %cl, (%rdi)
movzbl %cl, %ecx
movb 0x2(%rdi,%rcx), %dl
movb 0x1(%rdi), %r8b
addb %dl, %r8b
movb %r8b, 0x1(%rdi)
movzbl %r8b, %r8d
movb 0x2(%rdi,%r8), %r9b
movb %r9b, 0x2(%rdi,%rcx)
movb %dl, 0x2(%rdi,%r8)
addb 0x2(%rdi,%rcx), %dl
movzbl %dl, %ecx
movb 0x2(%rdi,%rcx), %cl
movb %cl, (%rsi)
incq %rsi
cmpq %rax, %rsi
jb 0x39bec
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_release_kv_engine
static void pager_release_kv_engine(Pager *pPager)
{
	unqlite_kv_engine *pEngine = pPager->pEngine;
	unqlite_db *pStorage = &pPager->pDb->sDB;
	if( pStorage->pCursor ){
		/* Release the associated cursor */
		unqliteReleaseCursor(pPager->pDb,pStorage->pCursor);
		pStorage->pCursor = 0;
	}
	if( pEngine->pIo->pMethods->xRelease ){
		pEngine->pIo->pMethods->xRelease(pEngine);
	}
	/* Release the whole instance */
	SyMemBackendFree(&pPager->pDb->sMem,(void *)pEngine->pIo);
	SyMemBackendFree(&pPager->pDb->sMem,(void *)pEngine);
	pPager->pEngine = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r14
movq 0xe8(%r15), %r12
testq %r12, %r12
je 0x3a338
movq 0xd8(%r15), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0xb0(%rax), %rax
testq %rax, %rax
je 0x3a322
movq %r12, %rdi
callq *%rax
movq %r15, %rdi
movq %r12, %rsi
callq 0x2e659
movq $0x0, 0xe8(%r15)
movq (%r14), %rsi
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x3a350
movq %r14, %rdi
callq *%rax
movq (%r14), %rsi
movq 0x8(%rbx), %rdi
callq 0x3490d
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3490d
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteGenErrorFormat
UNQLITE_PRIVATE int unqliteGenErrorFormat(unqlite *pDb,const char *zFmt,...)
{
	va_list ap;
	int rc;
	va_start(ap,zFmt);
	rc = SyBlobFormatAp(&pDb->sErr,zFmt,ap);
	va_end(ap);
	/* Append a new line */
	SyBlobAppend(&pDb->sErr,(const void *)"\n",sizeof(char));
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r10
movq %rdi, %rbx
leaq -0xe0(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x3a3cc
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %rax
movq %rsi, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
movq %rcx, (%rax)
addq $0xb8, %rbx
leaq -0xc(%rbp), %r8
movl $0x0, (%r8)
movq %rax, (%rsp)
movl $0x6, %edi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r10, %r9
callq 0x34a80
leaq 0x3dec7(%rip), %rsi     # 0x782e1
movq %rbx, %rdi
movl $0x1, %edx
callq 0x359ad
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteKvIoNewPage
static int unqliteKvIoNewPage(unqlite_kv_handle pHandle,unqlite_page **ppPage)
{
	Pager *pPager = (Pager *)pHandle;
	int rc;
	/* 
	 * Acquire a reader-lock first so that pPager->dbSize get initialized.
	 */
	rc = pager_shared_lock(pPager);
	if( rc == UNQLITE_OK ){
		rc = unqlitePagerAcquire(pPager,pPager->dbSize == 0 ? /* Page 0 is reserved */ 1 : pPager->dbSize ,ppPage,0,0);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3acaa
testl %eax, %eax
je 0x3a467
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%r14), %rsi
cmpq $0x1, %rsi
adcq $0x0, %rsi
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x3ab08
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unqliteKvIoPageDontJournal
static int unqliteKvIoPageDontJournal(unqlite_page *pRaw)
{
	Page *pPage = (Page *)pRaw;
	Pager *pPager;
	if( pPage == 0 ){
		/* TICKET 1433-0348 */
		return UNQLITE_OK;
	}
	pPager = pPage->pPager;
	if( pPager->iState >= PAGER_WRITER_LOCKED ){
		if( !pPager->no_jrnl && pPager->pVec && !unqliteBitvecTest(pPager->pVec,pPage->iPage) ){
			unqliteBitvecSet(pPager->pVec,pPage->iPage);
		}
	}
	return UNQLITE_OK;
}

// Assembly:
testq %rdi, %rdi
je 0x3a9d0
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
cmpl $0x2, 0x1f0(%rax)
jl 0x3a9cc
cmpl $0x0, 0x204(%rax)
je 0x3a9d3
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
movq 0x198(%rax), %rbx
testq %rbx, %rbx
je 0x3a9cc
movq 0x10(%rdi), %r14
movl 0xc(%rbx), %edi
movq 0x10(%rbx), %rsi
movq %r14, %rdx
callq 0x3be36
testl %eax, %eax
jne 0x3a9cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3beb7
jmp 0x3a9cc
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: pager_alloc_page
static Page * pager_alloc_page(Pager *pPager,pgno num_page)
{
	Page *pNew;
	
	pNew = (Page *)SyMemBackendPoolAlloc(pPager->pAllocator,sizeof(Page)+pPager->iPageSize);
	if( pNew == 0 ){
		return 0;
	}
	/* Zero the structure */
	SyZero(pNew,sizeof(Page)+pPager->iPageSize);
	/* Page data */
	pNew->zData = (unsigned char *)&pNew[1];
	/* Fill in the structure */
	pNew->pPager = pPager;
	pNew->nRef = 1;
	pNew->iPage = num_page;
	return pNew;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl 0x208(%r14), %esi
addl $0x68, %esi
callq 0x2e481
testq %rax, %rax
je 0x3b25f
movl 0x208(%r14), %ecx
addl $0x68, %ecx
je 0x3b246
addq %rax, %rcx
movq %rax, %rdx
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3b246
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3b246
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3b246
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jb 0x3b21a
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, (%rax)
movq %r14, 0x18(%rax)
movl $0x1, 0x24(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b455
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 0x33d86
testq %rax, %rax
je 0x3b45d
movq %rax, %r15
movl 0xc(%r13), %ecx
addl $0x8, %ecx
je 0x3b42b
movq %r15, %rax
addq %rcx, %rax
movq %r15, %rcx
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3b42b
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3b42b
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jae 0x3b42b
movb $0x0, (%rcx)
incq %rcx
cmpq %rax, %rcx
jb 0x3b3ff
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl -0x2c(%rbp), %ecx
callq *0x18(%r13)
movl %eax, %r12d
testl %eax, %eax
je 0x3b450
movq %r14, %rdi
movq %r15, %rsi
callq 0x3490d
xorl %r15d, %r15d
movq %r15, (%rbx)
jmp 0x3b463
movl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
jmp 0x3b463
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_O3/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 0x3ba70
movl %eax, %r15d
cmpl $-0xe, %eax
jne 0x3b4af
movq 0x178(%r14), %rax
testq %rax, %rax
je 0x3b4af
movq 0x180(%r14), %rdi
callq *%rax
testl %eax, %eax
jne 0x3b484
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3bac6
movl %esi, %r15d
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testl %eax, %eax
je 0x3babf
movl %eax, %r12d
movq 0x8(%r14), %rdi
cmpl $-0xe, %eax
leaq 0x38042(%rip), %rax     # 0x73aec
leaq 0x3806d(%rip), %rsi     # 0x73b1e
cmoveq %rax, %rsi
callq 0x31537
movl %r12d, %ebx
jmp 0x3bac6
movl %r15d, 0x1f4(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq