LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x3733b
movq (%r14), %rax
movq (%rax), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *0x10(%rax)
testl %eax, %eax
je 0x37334
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 0x3a16c
// File: /workspace/github_c_makefile_star2_O1/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 0x37385
movq (%r14), %rax
movq (%rax), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq *0x10(%rax)
testl %eax, %eax
je 0x3737e
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 0x3a214
// File: /workspace/github_c_makefile_star2_O1/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 0x3752a
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x3752a
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 0x37514
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 0x3750a
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 0x3a10e
testl %eax, %eax
jne 0x3750a
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 0x37459
movb $0x1, %cl
jmp 0x3750c
xorl %ecx, %ecx
testb %cl, %cl
movq -0x40(%rbp), %rcx
je 0x3751c
movq %rcx, %rdi
callq 0x39f6b
addq $0x38, %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: 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 0x37570
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x37570
movq %rsi, %rax
movl 0x50(%rdi), %esi
testl %esi, %esi
je 0x37577
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 0x39a56
// File: /workspace/github_c_makefile_star2_O1/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 0x3763b
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 0x37647
movl %eax, %esi
shll $0x5, %esi
movzbl (%rdi), %edx
addl %eax, %edx
addl %esi, %edx
incq %rdi
cmpq %rcx, %rdi
jae 0x37641
movl %edx, %eax
shll $0x5, %eax
movzbl (%rdi), %esi
addl %edx, %esi
addl %eax, %esi
incq %rdi
cmpq %rcx, %rdi
jae 0x37645
movl %esi, %edx
shll $0x5, %edx
movzbl (%rdi), %eax
addl %esi, %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jb 0x375e9
jmp 0x37647
movl $0x1505, %eax           # imm = 0x1505
retq
movl %edx, %eax
jmp 0x37647
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x376a7
movq 0x28(%rbx), %r12
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r15
xorl %r13d, %r13d
movq 0x60(%r12), %r14
leaq 0x40(%r12), %rdi
callq 0x31d8f
movq %r15, %rdi
movq %r12, %rsi
callq 0x2eb38
incl %r13d
movq %r14, %r12
cmpl 0x38(%rbx), %r13d
jb 0x37681
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
movq -0x30(%rbp), %r14
je 0x376bd
leaq 0x8(%r14), %rdi
callq 0x3503f
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2eb38
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_O1/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), %r12
movzwl 0x8(%rsi), %eax
testq %rax, %rax
jne 0x37737
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x376e7
movl 0x8(%r14), %eax
bswapl %eax
movl %eax, 0xc(%rbx)
movl $0xc, %eax
leaq (%r14,%rax), %r13
cmpl $0x0, 0xc(%rbx)
setne %cl
cmpq %r12, %rax
setl %al
andb %cl, %al
cmpb $0x1, %al
movq %r14, -0x30(%rbp)
jne 0x37787
addq %r14, %r12
movl $0x1, %r14d
movq (%r13), %rsi
movq 0x8(%r13), %rdx
bswapq %rsi
bswapq %rdx
movq %r15, %rdi
callq 0x377a1
testl %eax, %eax
jne 0x37792
addq $0x10, %r13
cmpl 0xc(%rbx), %r14d
jae 0x37787
incl %r14d
cmpq %r12, %r13
jb 0x3775b
subl -0x30(%rbp), %r13d
movw %r13w, 0x8(%rbx)
xorl %eax, %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: 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 0x38637
movq (%r14), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rdx
callq *0x10(%rax)
testl %eax, %eax
je 0x3864a
movq (%r14), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
callq *0x20(%rax)
testl %eax, %eax
jne 0x38699
jmp 0x38690
leaq 0x118(%r14), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x376e7
movq (%r14), %rax
movq 0xd0(%r14), %rdi
callq *0x28(%rax)
testl %eax, %eax
jne 0x38699
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_O1/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 0x2e951
testq %rax, %rax
je 0x38711
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x5c, %rcx
jb 0x386cf
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
testq %r14, %r14
movq %r14, %rcx
cmoveq %rax, %rcx
movq %rcx, 0x40(%rax)
cmpq %rax, %rcx
je 0x3870b
movq 0x48(%r14), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x48(%r14)
incl 0x58(%r14)
movq %rax, 0x8(%rbx)
jmp 0x38713
xorl %eax, %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: 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 0x3878b
xorl %r14d, %r14d
movw %r14w, (%r15)
movw $0xc, 0x12(%rbx)
movw $0xc00, 0x2(%r15)       # imm = 0xC00
movw %r14w, 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_O1/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
movq %rsi, -0x30(%rbp)
cmpl $0x0, 0x38(%rdi)
je 0x38ef8
movl %ecx, %ebx
movq %rdi, %r12
movq 0x20(%rdi), %rax
movl 0x3c(%rdi), %ecx
decl %ecx
andl %ebx, %ecx
movq (%rax,%rcx,8), %r13
testq %r13, %r13
je 0x38ef8
movl %edx, %r14d
movl %edx, %eax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl %ebx, (%r13)
jne 0x38eef
cmpl %r14d, 0x4(%r13)
jne 0x38eef
cmpl $0x0, 0x50(%r13)
je 0x38eb3
movq (%r12), %rax
movq 0x48(%r13), %rsi
movq -0x30(%rbp), %rdi
movl %r14d, %edx
callq *0xc8(%rax)
testl %eax, %eax
jne 0x38eef
jmp 0x38f0d
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%r12), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x40(%rbp)
movq %r13, %rdi
leaq 0xcee(%rip), %rsi       # 0x39bca
leaq -0x50(%rbp), %rdx
xorl %ecx, %ecx
callq 0x39a56
testl %eax, %eax
cmoveq %r13, %r15
je 0x38efb
movq 0x70(%r13), %r13
testq %r13, %r13
jne 0x38e85
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r15
jmp 0x38efb
// File: /workspace/github_c_makefile_star2_O1/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 0x2e951
testq %rax, %rax
je 0x39270
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x7c, %rcx
jb 0x39246
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movq %r14, 0x40(%rax)
movl $0x0, 0x58(%rax)
movq %rbx, 0x20(%rax)
jmp 0x39272
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: 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 0x3979a
addq $0x70, %rcx
jmp 0x397aa
movl 0x3c(%r14), %ecx
decl %ecx
andl (%rbx), %ecx
shlq $0x3, %rcx
addq 0x20(%r14), %rcx
movq %rax, (%rcx)
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x397be
movq 0x78(%rbx), %rcx
movq %rcx, 0x78(%rax)
movq 0x28(%r14), %rax
cmpq %rbx, %rax
jne 0x397cf
movq 0x60(%rax), %rax
movq %rax, 0x28(%r14)
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x397e0
movq 0x60(%rbx), %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rbx), %rcx
testq %rcx, %rcx
je 0x397ed
movq %rax, 0x68(%rcx)
cmpq %rbx, 0x30(%r14)
jne 0x397fb
movq 0x68(%rbx), %rax
movq %rax, 0x30(%r14)
decl 0x38(%r14)
leaq 0x40(%rbx), %rdi
callq 0x31d8f
movq (%r14), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2eb38
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhCellWriteLocalPayload
static int lhCellWriteLocalPayload(lhcell *pCell,
	const void *pKey,sxu32 nKeylen,
	const void *pData,unqlite_int64 nDatalen
	)
{
	/* A writer lock have been acquired on this page */
	lhpage *pPage = pCell->pPage;
	unsigned char *zRaw = pPage->pRaw->zData;
	/* Seek to the desired location */
	zRaw += pCell->iStart + L_HASH_CELL_SZ;
	/* Write the key */
	SyMemcpy(pKey,(void *)zRaw,nKeylen);
	zRaw += nKeylen;
	if( nDatalen > 0 ){
		/* Write the Data */
		SyMemcpy(pData,(void *)zRaw,(sxu32)nDatalen);
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %r15d
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movzwl 0x28(%rdi), %ecx
leaq (%rax,%rcx), %r12
addq $0x1a, %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x34fc5
testq %rbx, %rbx
jle 0x39871
movl %r15d, %eax
addq %rax, %r12
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x34fc5
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: lhCellWriteHeader
static int lhCellWriteHeader(lhcell *pCell)
{
	lhpage *pPage = pCell->pPage;
	unsigned char *zRaw = pPage->pRaw->zData;
	/* Seek to the desired location */
	zRaw += pCell->iStart;
	/* 4 byte hash number */
	SyBigEndianPack32(zRaw,pCell->nHash);
	zRaw += 4;
	/* 4 byte key length */
	SyBigEndianPack32(zRaw,pCell->nKey);
	zRaw += 4;
	/* 8 byte data length */
	SyBigEndianPack64(zRaw,pCell->nData);
	zRaw += 8;
	/* 2 byte offset of the next cell */
	pCell->iNext = pPage->sHdr.iOfft;
	SyBigEndianPack16(zRaw,pCell->iNext);
	zRaw += 2;
	/* 8 byte overflow page number */
	SyBigEndianPack64(zRaw,pCell->iOvfl);
	/* Update the page header */
	pPage->sHdr.iOfft = pCell->iStart;
	/* pEngine->pIo->xWrite() has been successfully called on this page */
	SyBigEndianPack16(pPage->pRaw->zData,pCell->iStart);
	/* All done */
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movzwl 0x28(%rdi), %edx
movl (%rdi), %esi
bswapl %esi
movl %esi, (%rcx,%rdx)
movl 0x4(%rdi), %esi
bswapl %esi
movl %esi, 0x4(%rcx,%rdx)
movq 0x8(%rdi), %rsi
bswapq %rsi
movq %rsi, 0x8(%rcx,%rdx)
movzwl 0x10(%rax), %ebx
movw %bx, 0x10(%rdi)
movb %bl, 0x11(%rcx,%rdx)
movb %bh, 0x10(%rcx,%rdx)
movq 0x18(%rdi), %rsi
bswapq %rsi
movq %rsi, 0x12(%rcx,%rdx)
movzwl 0x28(%rdi), %ecx
movw %cx, 0x10(%rax)
movq 0x8(%rax), %rax
movq (%rax), %rax
rolw $0x8, %cx
movw %cx, (%rax)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x39bfc
movq %rdx, %r14
movl %ebx, %edx
callq *0x10(%r14)
movl %eax, %ecx
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
testl %ecx, %ecx
jne 0x39c06
movl %ebx, %eax
addq %rax, (%r14)
xorl %eax, %eax
jmp 0x39c06
testl %ebx, %ebx
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
cmovel %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a01c
movq 0x20(%rbx), %rcx
movq 0x40(%rcx), %rax
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x39fb5
cmpq %rcx, 0x20(%rax)
jne 0x39faf
movzwl 0x10(%rax), %edx
cmpw 0x28(%rbx), %dx
je 0x39fb7
movq 0x68(%rax), %rax
jmp 0x39f9a
xorl %eax, %eax
movzwl 0x10(%rbx), %ecx
testq %rax, %rax
je 0x39fdc
movw %cx, 0x10(%rax)
movq 0x8(%r14), %rcx
movq (%rcx), %rcx
movzwl 0x28(%rax), %eax
addq %rcx, %rax
addq $0x10, %rax
movzwl 0x10(%rbx), %ecx
jmp 0x39fe8
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 0x3a003
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 0x3a021
movq %rbx, %rdi
callq 0x39775
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: lhRestoreSpace
static int lhRestoreSpace(lhpage *pPage,sxu16 iOfft,sxu16 nByte)
{
	unsigned char *zRaw;
	if( nByte < 4 ){
		/* At least 4 bytes of freespace must form a valid block */
		return UNQLITE_OK;
	}
	/* pEngine->pIo->xWrite() has been successfully called on this page */
	zRaw = &pPage->pRaw->zData[iOfft];
	/* Mark as a free block */
	SyBigEndianPack16(zRaw,pPage->sHdr.iFree); /* Offset of the next free block */
	zRaw += 2;
	SyBigEndianPack16(zRaw,nByte);
	/* Link */
	SyBigEndianPack16(&pPage->pRaw->zData[2/* offset of the first cell */],iOfft);
	pPage->sHdr.iFree = iOfft;
	pPage->nFree += nByte;
	return UNQLITE_OK;
}

// Assembly:
cmpw $0x4, %dx
jb 0x3a064
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rcx
movzwl %si, %eax
movzwl 0x12(%rdi), %ebx
movb %bl, 0x1(%rcx,%rax)
movb %bh, (%rcx,%rax)
movb %dl, 0x3(%rcx,%rax)
movb %dh, 0x2(%rcx,%rax)
movq 0x8(%rdi), %rcx
movq (%rcx), %rcx
movl %eax, %esi
rolw $0x8, %si
movw %si, 0x2(%rcx)
movw %ax, 0x12(%rdi)
addw %dx, 0x5c(%rdi)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rcx, %r8
movq %rdx, %r9
movl %esi, %r14d
movq %rdi, %rbx
movzwl 0x28(%rdi), %eax
movq 0x20(%rdi), %rdx
movq 0x40(%rdx), %rcx
movq 0x30(%rcx), %rdi
testq %rdi, %rdi
je 0x3a09f
cmpq %rdx, 0x20(%rdi)
jne 0x3a099
cmpw %ax, 0x10(%rdi)
je 0x3a0a1
movq 0x68(%rdi), %rdi
jmp 0x3a088
xorl %edi, %edi
movq 0x8(%rdx), %rcx
movq (%rcx), %rsi
testq %rdi, %rdi
je 0x3a0c7
movzwl 0x28(%rdi), %r10d
addq %r10, %rsi
addq $0x10, %rsi
movzwl 0x10(%rbx), %r11d
movl %r11d, %ecx
movb %r11b, 0x1(%rsi)
jmp 0x3a0d4
movzwl 0x10(%rbx), %edi
movl %edi, %ecx
movb %dil, 0x1(%rsi)
movq %rdx, %rdi
movb %ch, (%rsi)
movzwl 0x10(%rbx), %ecx
movw %cx, 0x10(%rdi)
addl $0x1a, %eax
movw %r14w, 0x28(%rbx)
movq %r8, 0x8(%rbx)
movq 0x8(%rdx), %rcx
movzwl %ax, %esi
addq (%rcx), %rsi
movl 0x4(%rbx), %edx
movq %rbx, %rdi
movq %r9, %rcx
callq 0x3981b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3987a
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhRestorePage
static int lhRestorePage(lhash_kv_engine *pEngine,unqlite_page *pPage)
{
	int rc;
	rc = pEngine->pIo->xWrite(pEngine->pHeader);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	rc = pEngine->pIo->xWrite(pPage);
	if( rc != UNQLITE_OK ){
		return rc;
	}
	/* Link to the list of free page */
	SyBigEndianPack64(pPage->zData,pEngine->nFreeList);
	pEngine->nFreeList = pPage->iPage;
	SyBigEndianPack64(&pEngine->pHeader->zData[4/*Magic*/+4/*Hash*/],pEngine->nFreeList);
	/* All done */
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0xd0(%rdi), %rdi
callq *0x28(%rax)
testl %eax, %eax
jne 0x3a167
movq (%rbx), %rax
movq %r14, %rdi
callq *0x28(%rax)
testl %eax, %eax
jne 0x3a167
movq (%r14), %rax
movq 0x118(%rbx), %rcx
bswapq %rcx
movq %rcx, (%rax)
movq 0x10(%r14), %rax
movq %rax, 0x118(%rbx)
movq 0xd0(%rbx), %rcx
movq (%rcx), %rcx
bswapq %rax
movq %rax, 0x8(%rcx)
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: 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 0x3a1e6
leaq -0x20(%rbp), %r14
cmpl $0x2, 0x8(%rbx)
jne 0x3a1a6
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3a1a6
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 0x38b86
testl %eax, %eax
jne 0x3a209
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
testq %rcx, %rcx
jne 0x3a1f4
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movq (%rcx), %rax
callq *0x50(%rax)
movq 0x20(%rbx), %r15
testq %r15, %r15
jne 0x3a186
movl $0x3, 0x8(%rbx)
movl $0xffffffe4, %eax       # imm = 0xFFFFFFE4
jmp 0x3a209
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_O1/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 0x3a28e
leaq -0x20(%rbp), %r14
cmpl $0x2, 0x8(%rbx)
jne 0x3a24e
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3a24e
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 0x38b86
testl %eax, %eax
jne 0x3a2b1
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
testq %rcx, %rcx
jne 0x3a29c
movq (%rax), %rcx
movq 0x8(%rax), %rdi
movq (%rcx), %rax
callq *0x50(%rax)
movq 0x20(%rbx), %r15
testq %r15, %r15
jne 0x3a22e
movl $0x3, 0x8(%rbx)
movl $0xffffffe4, %eax       # imm = 0xFFFFFFE4
jmp 0x3a2b1
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_O1/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 0x3a2db
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x3a2db
callq 0x3503f
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_O1/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 0x3a339
movq 0xf8(%rbx), %rdi
movq 0x6d8(%rdi), %r14
movl $0xdead2bad, 0x6e8(%rdi) # imm = 0xDEAD2BAD
callq 0x2ea67
movl 0x100(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x100(%rbx)
movq %r14, %rdi
cmpl $0x1, %eax
jg 0x3a30c
movl $0x7635, 0x118(%rbx)    # imm = 0x7635
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2ea67
// File: /workspace/github_c_makefile_star2_O1/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 0x5c438(%rip), %r12d    # 0x967a0
testq %r12, %r12
je 0x3a3d9
movl %esi, %ebx
movq 0x5c422(%rip), %r13     # 0x96798
xorl %r14d, %r14d
movq (%r13,%r14,8), %r15
movq (%r15), %rdi
cmpb $0x0, (%rdi)
movq %rdi, %rax
je 0x3a3bc
leaq 0x2(%rdi), %rax
cmpb $0x0, -0x1(%rax)
je 0x3a3b4
cmpb $0x0, (%rax)
je 0x3a3bc
cmpb $0x0, 0x1(%rax)
je 0x3a3b9
leaq 0x4(%rax), %rcx
cmpb $0x0, 0x2(%rax)
movq %rcx, %rax
jne 0x3a38d
addq $-0x2, %rcx
movq %rcx, %rax
jmp 0x3a3bc
decq %rax
jmp 0x3a3bc
incq %rax
subl %edi, %eax
cmpl %ebx, %eax
jne 0x3a3d1
movq -0x30(%rbp), %rsi
movl %ebx, %edx
callq 0x3a837
testl %eax, %eax
je 0x3a3dc
incq %r14
cmpq %r12, %r14
jne 0x3a379
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_O1/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 0x3a4c1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0x3b577(%rip), %rdi     # 0x7598a
xorl %esi, %esi
xorl %eax, %eax
callq 0xc510
testl %eax, %eax
js 0x3a438
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
movl %eax, %edi
callq 0xc890
testq %rax, %rax
jg 0x3a462
callq 0xcc70
leaq -0xc(%rbp), %rdi
movl %eax, (%rdi)
leaq -0x110(%rbp), %rsi
movl $0x4, %edx
callq 0x34fc5
leaq -0x10c(%rbp), %rdi
xorl %esi, %esi
callq 0xc5a0
movw $0x0, (%rbx)
xorl %eax, %eax
movb %al, 0x2(%rbx,%rax)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x3a469
movb 0x1(%rbx), %al
xorl %ecx, %ecx
movb 0x2(%rbx,%rcx), %dl
movb -0x110(%rbp,%rcx), %sil
addb %dl, %sil
addb %sil, %al
movzbl %al, %esi
movb 0x2(%rbx,%rsi), %dil
movb %dl, 0x2(%rbx,%rsi)
movb %dil, 0x2(%rbx,%rcx)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x3a47d
movb %al, 0x1(%rbx)
movw $0x13c4, 0x102(%rbx)    # imm = 0x13C4
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a5f1
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 0x3a5f0
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 0x3a5f0
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 0x3a5f0
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 0x3a4e4
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ac13
movq 0xd8(%r15), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0xb0(%rax), %rax
testq %rax, %rax
je 0x3abfd
movq %r12, %rdi
callq *%rax
movq %r15, %rdi
movq %r12, %rsi
callq 0x2eb38
movq $0x0, 0xe8(%r15)
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x3ac28
movq %r14, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0x3503f
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3503f
movq $0x0, 0x10(%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: 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 0x3aca7
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 0x351b4
leaq 0x3f5ec(%rip), %rsi     # 0x7a2e1
movq %rbx, %rdi
movl $0x1, %edx
callq 0x360ae
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b5ca
testl %eax, %eax
je 0x3ad42
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 0x3b41c
// File: /workspace/github_c_makefile_star2_O1/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 0x3b2e8
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
cmpl $0x2, 0x1f0(%rax)
jl 0x3b2e4
cmpl $0x0, 0x204(%rax)
je 0x3b2eb
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
movq 0x198(%rax), %rbx
testq %rbx, %rbx
je 0x3b2e4
movq 0x10(%rdi), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c7bd
testl %eax, %eax
jne 0x3b2e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c842
jmp 0x3b2e4
// File: /workspace/github_c_makefile_star2_O1/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 0x2e951
testq %rax, %rax
je 0x3bbd4
movl 0x208(%r14), %ecx
addl $0x68, %ecx
je 0x3bbb9
addq %rax, %rcx
movq %rax, %rdx
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3bbb9
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3bbb9
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jae 0x3bbb9
movb $0x0, (%rdx)
incq %rdx
cmpq %rcx, %rdx
jb 0x3bb8d
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, (%rax)
movq %r14, 0x18(%rax)
movl $0x1, 0x24(%rax)
movq %rbx, 0x10(%rax)
jmp 0x3bbd6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq