LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: Systrcpy
JX9_PRIVATE sxu32 Systrcpy(char *zDest, sxu32 nDestLen, const char *zSrc, sxu32 nLen)
{
	unsigned char *zBuf = (unsigned char *)zDest;
	unsigned char *zIn = (unsigned char *)zSrc;
	unsigned char *zEnd;
#if defined(UNTRUST)
	if( zSrc == (const char *)zDest ){
			return 0;
	}
#endif
	if( nLen <= 0 ){
		nLen = SyStrlen(zSrc);
	}
	zEnd = &zBuf[nDestLen - 1]; /* reserve a room for the null terminator */
	for(;;){
		if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
		if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
		if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
		if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
	}
	zBuf[0] = 0;
	return (sxu32)(zBuf-(unsigned char *)zDest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
testl %ecx, %ecx
jne 0x3447e
cmpb $0x0, (%rdx)
movq %rdx, %rcx
je 0x3447c
leaq 0x2(%rdx), %rcx
cmpb $0x0, -0x1(%rcx)
je 0x34474
cmpb $0x0, (%rcx)
je 0x3447c
cmpb $0x0, 0x1(%rcx)
je 0x34479
leaq 0x4(%rcx), %rax
cmpb $0x0, 0x2(%rcx)
movq %rax, %rcx
jne 0x3444d
addq $-0x2, %rax
movq %rax, %rcx
jmp 0x3447c
decq %rcx
jmp 0x3447c
incq %rcx
subl %edx, %ecx
movq %rdi, %rax
decl %esi
je 0x3451c
movq %rdi, %rax
testl %ecx, %ecx
je 0x3451c
addq %rdi, %rsi
movl %ecx, %ecx
leaq -0x1(%rcx), %r8
leaq -0x2(%rcx), %r9
leaq -0x4(%rcx), %r10
addq $-0x3, %rcx
xorl %r11d, %r11d
movb (%rdx,%r11), %bl
leaq (%rdi,%r11), %rax
incq %rax
movb %bl, -0x1(%rax)
cmpq %rsi, %rax
jae 0x3451c
cmpl %r11d, %r8d
je 0x3451c
movb 0x1(%rdx,%r11), %bl
leaq (%rdi,%r11), %rax
addq $0x2, %rax
movb %bl, -0x1(%rax)
cmpq %rsi, %rax
jae 0x3451c
cmpl %r11d, %r9d
je 0x3451c
movb 0x2(%rdx,%r11), %bl
leaq (%rdi,%r11), %rax
addq $0x3, %rax
movb %bl, -0x1(%rax)
cmpq %rsi, %rax
jae 0x3451c
cmpl %r11d, %ecx
je 0x3451c
movb 0x3(%rdx,%r11), %al
leaq (%rdi,%r11), %rbx
addq $0x4, %rbx
movb %al, -0x1(%rbx)
leaq 0x4(%r11), %rax
cmpq %rsi, %rbx
jae 0x34519
cmpl %r11d, %r10d
movq %rax, %r11
jne 0x344ac
addq %rdi, %rax
movb $0x0, (%rax)
subl %edi, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unixClose
static int unixClose(unqlite_file *id){
  int rc = UNQLITE_OK;
  if( id ){
    unixFile *pFile = (unixFile *)id;
    unixUnlock(id, NO_LOCK);
    unixEnterMutex();
    if( pFile->pInode && pFile->pInode->nLock ){
      /* If there are outstanding locks, do not actually close the file just
      ** yet because that would clear those locks.  Instead, add the file
      ** descriptor to pInode->pUnused list.  It will be automatically closed 
      ** when the last lock is cleared.
      */
      setPendingFd(pFile);
    }
    releaseInodeInfo(pFile);
    rc = closeUnixFile(id);
    unixLeaveMutex();
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x345f5
movq %rdi, %rbx
xorl %esi, %esi
callq 0x34b73
movl $0x4, 0x6232d(%rip)     # 0x96878
leaq 0x622fe(%rip), %rdi     # 0x96850
callq 0xc330
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x345d6
cmpl $0x0, 0x1c(%r14)
je 0x34586
movq 0x28(%rbx), %rax
movq 0x20(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x20(%r14)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
movq $0x0, 0x28(%rbx)
testq %r14, %r14
je 0x345d6
decl 0x18(%r14)
jne 0x345d6
movq %rbx, %rdi
callq 0x34dd9
movq 0x30(%r14), %rax
leaq 0x28(%rax), %rcx
testq %rax, %rax
leaq 0x62b2d(%rip), %rax     # 0x970d8
cmovneq %rcx, %rax
movq 0x28(%r14), %rcx
movq %rcx, (%rax)
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x345c7
movq 0x30(%r14), %rcx
movq %rcx, 0x30(%rax)
leaq 0x620f2(%rip), %rdi     # 0x966c0
movq %r14, %rsi
callq 0x3503f
movl 0x14(%rbx), %edi
testl %edi, %edi
js 0x3460c
callq 0xc2b0
movl %eax, %r15d
testl %eax, %eax
je 0x345fa
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
jmp 0x34601
xorl %r14d, %r14d
jmp 0x34671
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
testl %r15d, %r15d
jne 0x3465b
movl 0x10(%rbx), %edi
testl %edi, %edi
js 0x3462e
callq 0xc2b0
testl %eax, %eax
je 0x3462e
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x3465b
movq 0x28(%rbx), %rsi
leaq 0x62087(%rip), %rdi     # 0x966c0
callq 0x3503f
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x40(%rbx)
xorl %r14d, %r14d
movl $0x4, 0x62213(%rip)     # 0x96878
leaq 0x621e4(%rip), %rdi     # 0x96850
callq 0xc2d0
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: unixRead
static int unixRead(
  unqlite_file *id, 
  void *pBuf, 
  unqlite_int64 amt,
  unqlite_int64 offset
){
  unixFile *pFile = (unixFile *)id;
  int got;
  
  got = seekAndRead(pFile, offset, pBuf, (int)amt);
  if( got==(int)amt ){
    return UNQLITE_OK;
  }else if( got<0 ){
    /* lastErrno set by seekAndRead */
    return UNQLITE_IOERR;
  }else{
    pFile->lastErrno = 0; /* not a system error */
    /* Unread parts of the buffer must be zero-filled */
    SyZero(&((char*)pBuf)[got],(sxu32)amt-got);
    return UNQLITE_IOERR;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x10(%rdi), %edi
xorl %r13d, %r13d
movq %rcx, %rsi
xorl %edx, %edx
callq 0xc340
cmpq %r12, %rax
jne 0x346c7
movl 0x10(%r15), %edi
movslq %r14d, %rdx
movq %rbx, %rsi
callq 0xc890
movq %rax, %r12
testl %r12d, %r12d
jns 0x346df
jmp 0x346d3
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
jne 0x346db
callq 0xcb20
movl (%rax), %r13d
movl %r13d, 0x1c(%r15)
xorl %eax, %eax
movl %r14d, %ecx
subl %r12d, %ecx
je 0x34700
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testl %r12d, %r12d
js 0x34700
movl $0x0, 0x1c(%r15)
cmpl %r12d, %r14d
jne 0x3470f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, %edx
addq %rdx, %rbx
addq %rbx, %rcx
movb $0x0, (%rbx)
incq %rbx
cmpq %rcx, %rbx
jae 0x34700
movb $0x0, (%rbx)
incq %rbx
cmpq %rcx, %rbx
jae 0x34700
movb $0x0, (%rbx)
incq %rbx
cmpq %rcx, %rbx
jae 0x34700
movb $0x0, (%rbx)
incq %rbx
cmpq %rcx, %rbx
jb 0x34718
jmp 0x34700
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unixWrite
static int unixWrite(
  unqlite_file *id, 
  const void *pBuf, 
  unqlite_int64 amt,
  unqlite_int64 offset 
){
  unixFile *pFile = (unixFile*)id;
  int wrote = 0;

  while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
    amt -= wrote;
    offset += wrote;
    pBuf = &((char*)pBuf)[wrote];
  }
  
  if( amt>0 ){
    if( wrote<0 ){
      /* lastErrno set by seekAndWrite */
      return UNQLITE_IOERR;
    }else{
      pFile->lastErrno = 0; /* not a system error */
      return UNQLITE_FULL;
    }
  }
  return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
testq %rdx, %rdx
setg %bl
jle 0x347f1
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq -0x30(%rbp), %r13
movl 0x10(%r13), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc340
cmpq %r14, %rax
jne 0x347ab
movl 0x10(%r13), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0xcb50
movq %rax, %r13
testl %r13d, %r13d
jns 0x347cc
callq 0xcb20
movl (%rax), %eax
movq -0x30(%rbp), %rcx
movl %eax, 0x1c(%rcx)
jmp 0x347cc
cmpq $-0x1, %rax
je 0x347bb
movl $0x0, 0x1c(%r13)
jmp 0x347c6
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%r13)
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %r13d, %r13d
jle 0x347eb
movl %r13d, %eax
addq %rax, %r14
addq %rax, %r12
movq %r15, %rcx
subq %rax, %rcx
testq %rcx, %rcx
setg %bl
subq %rax, %r15
jg 0x3476d
shrl $0x1f, %r13d
jmp 0x347f4
xorl %r13d, %r13d
movl %ebx, %eax
notb %al
movzbl %al, %eax
andl $0x1, %eax
leal -0x2(,%rax,2), %eax
testb %r13b, %r13b
jne 0x3481f
testb $0x1, %bl
je 0x3481f
movq -0x30(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl $0xffffffb7, %eax       # imm = 0xFFFFFFB7
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: unixTruncate
static int unixTruncate(unqlite_file *id, sxi64 nByte){
  unixFile *pFile = (unixFile *)id;
  int rc;

  rc = ftruncate(pFile->h, (off_t)nByte);
  if( rc ){
    pFile->lastErrno = errno;
    return UNQLITE_IOERR;
  }else{
    return UNQLITE_OK;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %edi
callq 0xcd10
testl %eax, %eax
je 0x34854
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x34856
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unixFileSize
static int unixFileSize(unqlite_file *id,sxi64 *pSize){
  int rc;
  struct stat buf;
  
  rc = fstat(((unixFile*)id)->h, &buf);
  
  if( rc!=0 ){
    ((unixFile*)id)->lastErrno = errno;
    return UNQLITE_IOERR;
  }
  *pSize = buf.st_size;

  /* When opening a zero-size database, the findInodeInfo() procedure
  ** writes a single byte into that file in order to work around a bug
  ** in the OS-X msdos filesystem.  In order to avoid problems with upper
  ** layers, we need to report this file size as zero even though it is
  ** really 1.   Ticket #3260.
  */
  if( *pSize==1 ) *pSize = 0;

  return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %edi
leaq -0xa0(%rbp), %rsi
callq 0xc9b0
testl %eax, %eax
je 0x348e9
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%r14)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x348ff
movq -0x70(%rbp), %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movl $0x0, %edx
cmovneq %rcx, %rdx
movq %rdx, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: unixCheckReservedLock
static int unixCheckReservedLock(unqlite_file *id, int *pResOut){
  int rc = UNQLITE_OK;
  int reserved = 0;
  unixFile *pFile = (unixFile*)id;

 
  unixEnterMutex(); /* Because pFile->pInode is shared across threads */

  /* Check if a thread in this process holds such a lock */
  if( pFile->pInode->eFileLock>SHARED_LOCK ){
    reserved = 1;
  }

  /* Otherwise see if some other process holds it.
  */
  if( !reserved ){
    struct flock lock;
    lock.l_whence = SEEK_SET;
    lock.l_start = RESERVED_BYTE;
    lock.l_len = 1;
    lock.l_type = F_WRLCK;
    if (-1 == fcntl(pFile->h, F_GETLK, &lock)) {
      int tErrno = errno;
	  rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
      pFile->lastErrno = tErrno;
    } else if( lock.l_type!=F_UNLCK ){
      reserved = 1;
    }
  }
  
  unixLeaveMutex();
 
  *pResOut = reserved;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x4, 0x61b4e(%rip)     # 0x96878
leaq 0x61b1f(%rip), %rdi     # 0x96850
callq 0xc330
movq 0x8(%r15), %rax
cmpl $0x1, 0x14(%rax)
jg 0x34d80
leaq -0x40(%rbp), %rdx
movq $0x40000001, 0x8(%rdx)  # imm = 0x40000001
movq $0x1, 0x10(%rdx)
movl $0x1, (%rdx)
movl 0x10(%r15), %edi
xorl %r14d, %r14d
movl $0x5, %esi
xorl %eax, %eax
callq 0xc1b0
cmpl $-0x1, %eax
je 0x34d8b
xorl %r15d, %r15d
cmpw $0x2, -0x40(%rbp)
setne %r15b
jmp 0x34da5
xorl %r14d, %r14d
movl $0x1, %r15d
jmp 0x34da5
callq 0xcb20
movl (%rax), %r12d
movl %r12d, %edi
callq 0x34e66
movl %eax, %r14d
movl %r12d, 0x1c(%r15)
xorl %r15d, %r15d
movl $0x4, 0x61ac9(%rip)     # 0x96878
leaq 0x61a9a(%rip), %rdi     # 0x96850
callq 0xc2d0
movl %r15d, (%rbx)
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: closePendingFds
static int closePendingFds(unixFile *pFile){
  int rc = UNQLITE_OK;
  unixInodeInfo *pInode = pFile->pInode;
  UnixUnusedFd *pError = 0;
  UnixUnusedFd *p;
  UnixUnusedFd *pNext;
  for(p=pInode->pUnused; p; p=pNext){
    pNext = p->pNext;
    if( close(p->fd) ){
      pFile->lastErrno = errno;
	  rc = UNQLITE_IOERR;
      p->pNext = pError;
      pError = p;
    }else{
      unqlite_free(p);
    }
  }
  pInode->pUnused = pError;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %r12
testq %r12, %r12
je 0x34e46
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x8(%r12), %r14
movl (%r12), %edi
callq 0xc2b0
testl %eax, %eax
je 0x34e2d
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movq %r13, 0x8(%r12)
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
movq %r12, %r13
jmp 0x34e3c
leaq 0x6188c(%rip), %rdi     # 0x966c0
movq %r12, %rsi
callq 0x3503f
movq %r14, %r12
testq %r14, %r14
jne 0x34e01
jmp 0x34e4c
xorl %r13d, %r13d
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
movq %r13, 0x20(%rax)
movl %r15d, %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: SyMemcmp
JX9_PRIVATE sxi32 SyMemcmp(const void *pB1, const void *pB2, sxu32 nSize)
{
	sxi32 rc;
	if( nSize <= 0 ){
		return 0;
	}
	if( pB1 == 0 || pB2 == 0 ){
		return pB1 != 0 ? 1 : (pB2 == 0 ? 0 : -1);
	}
	SX_MACRO_FAST_CMP(pB1, pB2, nSize, rc);
	return rc;
}

// Assembly:
testl %edx, %edx
je 0x34ee5
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x34ee8
xorl %ecx, %ecx
negq %rsi
sbbl %ecx, %ecx
testq %rdi, %rdi
movl $0x1, %eax
cmovel %ecx, %eax
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r10d
leaq -0x1(%r10), %r11
leaq -0x2(%r10), %rbx
leaq -0x3(%r10), %r14
xorl %r8d, %r8d
movq %rsi, %rcx
movq %rdi, %r9
movb (%rdi,%r8), %al
cmpb (%rsi,%r8), %al
jne 0x34f66
movb $0x1, %al
cmpl %r8d, %r11d
je 0x34f73
movb 0x1(%rdi,%r8), %dl
cmpb 0x1(%rsi,%r8), %dl
jne 0x34f7e
leaq 0x2(%r9), %rdx
cmpl %r8d, %ebx
je 0x34f8e
movb 0x2(%rdi,%r8), %r15b
cmpb 0x2(%rsi,%r8), %r15b
jne 0x34f98
leaq 0x3(%r9), %rdx
cmpl %r8d, %r14d
je 0x34f9e
movb 0x3(%rdi,%r8), %r15b
cmpb 0x3(%rsi,%r8), %r15b
jne 0x34fa4
addq $0x4, %r9
addq $0x4, %rcx
addq $0x4, %r8
cmpl %r8d, %r10d
jne 0x34f09
addq %r8, %rsi
jmp 0x34f6b
addq %r8, %rsi
xorl %eax, %eax
movq %r9, %rdx
movq %rsi, %rcx
jmp 0x34fae
incq %r9
incq %rcx
movq %r9, %rdx
jmp 0x34fae
leaq (%rsi,%r8), %rcx
incq %rcx
leaq (%rdi,%r8), %rdx
incq %rdx
jmp 0x34fac
leaq (%rsi,%r8), %rcx
addq $0x2, %rcx
jmp 0x34fae
addq $0x2, %rcx
jmp 0x34fac
addq $0x3, %rcx
jmp 0x34fae
leaq (%rsi,%r8), %rcx
addq $0x3, %rcx
xorl %eax, %eax
testb %al, %al
je 0x34fb6
xorl %eax, %eax
jmp 0x34fbe
movzbl (%rdx), %eax
movzbl (%rcx), %ecx
subl %ecx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendFree
JX9_PRIVATE sxi32 SyMemBackendFree(SyMemBackend *pBackend, void * pChunk)
{
	sxi32 rc;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) ){
		return SXERR_CORRUPT;
	}
#endif
	if( pChunk == 0 ){
		return SXRET_OK;
	}
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	rc = MemBackendFree(&(*pBackend), pChunk);
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x35088
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x35065
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x35065
callq *0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3508d
movq (%rbx), %rax
testq %rax, %rax
je 0x35088
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x35088
popq %rbx
popq %r14
popq %rbp
jmpq *0x30(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemBackendFree
static sxi32 MemBackendFree(SyMemBackend *pBackend, void * pChunk)
{
	SyMemBlock *pBlock;
	pBlock = (SyMemBlock *)(((char *)pChunk) - sizeof(SyMemBlock));
#if defined(UNTRUST)
	if( pBlock->nGuard != SXMEM_BACKEND_MAGIC ){
		return SXERR_CORRUPT;
	}
#endif
	/* Unlink from the list of active blocks */
	if( pBackend->nBlock > 0 ){
		/* Release the block */
#if defined(UNTRUST)
		/* Mark as stale block */
		pBlock->nGuard = 0x635B;
#endif
		MACRO_LD_REMOVE(pBackend->pBlocks, pBlock);
		pBackend->nBlock--;
		pBackend->pMethods->xFree(pBlock);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
je 0x350d7
leaq -0x10(%rsi), %rax
movq 0x10(%rdi), %rdx
cmpq %rax, %rdx
jne 0x350ac
movq (%rdx), %rdx
movq %rdx, 0x10(%rdi)
movq -0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x350bb
movq (%rax), %rsi
movq %rsi, (%rdx)
movq (%rax), %rsi
testq %rsi, %rsi
je 0x350c7
movq %rdx, 0x8(%rsi)
decl %ecx
movl %ecx, 0x18(%rdi)
movq 0x8(%rdi), %rcx
movq %rax, %rdi
popq %rbp
jmpq *0x10(%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyBufferFormat
JX9_PRIVATE sxu32 SyBufferFormat(char *zBuf, sxu32 nLen, const char *zFormat, ...)
{
	SyBlob sBlob;
	va_list ap;
	sxu32 n;
#if defined(UNTRUST)	
	if( SX_EMPTY_STR(zFormat) ){
		return 0;
	}
#endif	
	if( SXRET_OK != SyBlobInitFromBuf(&sBlob, zBuf, nLen - 1) ){
		return 0;
	}		
	va_start(ap, zFormat);
	FormatMount(SXFMT_CONS_BLOB, &sBlob, 0, 0, 0, zFormat, ap);
	va_end(ap);
	n = SyBlobLength(&sBlob);
	/* Append the null terminator */
	sBlob.mByte++;
	SyBlobAppend(&sBlob, "\0", sizeof(char));
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdx, %r10
leaq -0x100(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x35130
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
decl %esi
leaq -0x50(%rbp), %rbx
movq %rdi, 0x8(%rbx)
movl %esi, 0x14(%rbx)
movl $0x0, 0x10(%rbx)
movq $0x0, (%rbx)
movl $0x3, 0x18(%rbx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
leaq -0x30(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movq %rdx, 0x10(%rcx)
movq %rcx, (%rsp)
movl $0x6, %edi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r10, %r9
callq 0x351b4
movl 0x10(%rbx), %r14d
incl 0x14(%rbx)
leaq 0x3fa2c(%rip), %rsi     # 0x74bc4
movq %rbx, %rdi
movl $0x1, %edx
callq 0x360ae
movl %r14d, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyBlobAppend
JX9_PRIVATE sxi32 SyBlobAppend(SyBlob *pBlob, const void *pData, sxu32 nSize)
{
	sxu8 *zBlob;
	sxi32 rc;
	if( nSize < 1 ){
		return SXRET_OK;
	}
	rc = BlobPrepareGrow(&(*pBlob), &nSize);
	if( SXRET_OK != rc ){
		return rc;
	}
	if( pData ){
		zBlob = (sxu8 *)pBlob->pBlob ;
		zBlob = &zBlob[pBlob->nByte];
		pBlob->nByte += nSize;
		SX_MACRO_FAST_MEMCPY(pData, zBlob, nSize);
	}
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
je 0x3620b
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x18(%rdi), %eax
testb $0x3, %al
je 0x36102
movl 0x10(%r15), %ecx
movl 0x14(%r15), %edx
movl %edx, %eax
subl %ecx, %eax
xorl %r12d, %r12d
cmpl %r14d, %eax
jae 0x3618e
xorl %esi, %esi
cmpl %ecx, %edx
movl $0xffffffe3, %r12d      # imm = 0xFFFFFFE3
cmovnel %esi, %r12d
movl %eax, %r14d
jmp 0x3618e
testb $0x4, %al
je 0x3613c
movl 0x10(%r15), %edx
testl %edx, %edx
je 0x36129
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x36268
testq %rax, %rax
je 0x36188
movq %rax, 0x8(%r15)
movl 0x10(%r15), %eax
jmp 0x36133
movq $0x0, 0x8(%r15)
xorl %eax, %eax
movl %eax, 0x14(%r15)
andb $-0x5, 0x18(%r15)
movl 0x14(%r15), %eax
movl %eax, %ecx
subl 0x10(%r15), %ecx
xorl %r12d, %r12d
cmpl %r14d, %ecx
jae 0x3618e
testl %eax, %eax
je 0x3615c
leal (%r14,%rax,2), %r13d
addl $0x10, %r13d
jmp 0x3616a
cmpl $0x11, %r14d
movl $0x10, %r13d
cmovael %r14d, %r13d
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movl %r13d, %edx
callq 0x33b0f
testq %rax, %rax
je 0x36188
movq %rax, 0x8(%r15)
movl %r13d, 0x14(%r15)
jmp 0x3618e
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %r12d, %r12d
jne 0x3620e
testq %rbx, %rbx
je 0x3620b
movq 0x8(%r15), %rax
movl 0x10(%r15), %ecx
leal (%rcx,%r14), %edx
movl %edx, 0x10(%r15)
movl $0x0, %r12d
testl %r14d, %r14d
je 0x3620e
addq %rcx, %rax
movl %r14d, %ecx
leaq -0x1(%rcx), %rdx
leaq -0x2(%rcx), %rsi
leaq -0x3(%rcx), %rdi
xorl %r12d, %r12d
xorl %r8d, %r8d
movb (%rbx,%r8), %r9b
movb %r9b, (%rax,%r8)
cmpl %r8d, %edx
je 0x3620e
movb 0x1(%rbx,%r8), %r9b
movb %r9b, 0x1(%rax,%r8)
cmpl %r8d, %esi
je 0x3620e
movb 0x2(%rbx,%r8), %r9b
movb %r9b, 0x2(%rax,%r8)
cmpl %r8d, %edi
je 0x3620e
movb 0x3(%rbx,%r8), %r9b
movb %r9b, 0x3(%rax,%r8)
addq $0x4, %r8
cmpl %r8d, %ecx
jne 0x361cb
jmp 0x3620e
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: FormatConsumer
static sxi32 FormatConsumer(const void *pSrc, unsigned int nLen, void *pData)
{
	SyFmtConsumer *pConsumer = (SyFmtConsumer *)pData;
	sxi32 rc = SXERR_ABORT;
	switch(pConsumer->nType){
	case SXFMT_CONS_PROC:
			/* User callback */
			rc = pConsumer->uConsumer.sFunc.xUserConsumer(pSrc, nLen, pConsumer->uConsumer.sFunc.pUserData);
			break;
	case SXFMT_CONS_BLOB:
			/* Blob consumer */
			rc = SyBlobAppend(pConsumer->uConsumer.pBlob, pSrc, (sxu32)nLen);
			break;
		default: 
			/* Unknown consumer */
			break;
	}
	/* Update total number of bytes consumed so far */
	pConsumer->nLen += nLen;
	pConsumer->rc = rc;
	return rc;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %rsi
movl 0x4(%rdx), %ecx
cmpl $0x6, %ecx
je 0x36251
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
cmpl $0x1, %ecx
jne 0x3625d
movq 0x18(%rbx), %rdx
movq %rsi, %rdi
movl %r14d, %esi
callq *0x10(%rbx)
jmp 0x3625d
movq 0x10(%rbx), %rdi
movl %r14d, %edx
callq 0x360ae
addl %r14d, (%rbx)
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendDup
JX9_PRIVATE void * SyMemBackendDup(SyMemBackend *pBackend, const void *pSrc, sxu32 nSize)
{
	void *pNew;
#if defined(UNTRUST)
	if( pSrc == 0 || nSize <= 0 ){
		return 0;
	}
#endif
	pNew = SyMemBackendAlloc(&(*pBackend), nSize);
	if( pNew ){
		SyMemcpy(pSrc, pNew, nSize);
	}
	return pNew;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %esi
callq 0x343ed
movq %rax, %r15
testq %rax, %rax
je 0x36293
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x34fc5
movq %r15, %rax
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: UnixMutexNew
static SyMutex * UnixMutexNew(int nType)
{
	static SyMutex aStaticMutexes[] = {
		{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_1}, 
		{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_2}, 
		{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_3}, 
		{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_4}, 
		{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_5}, 
		{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_6}
	};
	SyMutex *pMutex;
	
	if( nType == SXMUTEX_TYPE_FAST || nType == SXMUTEX_TYPE_RECURSIVE ){
		pthread_mutexattr_t sRecursiveAttr;
  		/* Allocate a new mutex */
  		pMutex = (SyMutex *)malloc(sizeof(SyMutex));
  		if( pMutex == 0 ){
  			return 0;
  		}
  		if( nType == SXMUTEX_TYPE_RECURSIVE ){
  			pthread_mutexattr_init(&sRecursiveAttr);
  			pthread_mutexattr_settype(&sRecursiveAttr, PTHREAD_MUTEX_RECURSIVE);
  		}
  		pthread_mutex_init(&pMutex->sMutex, nType == SXMUTEX_TYPE_RECURSIVE ? &sRecursiveAttr : 0 );
		if(	nType == SXMUTEX_TYPE_RECURSIVE ){
   			pthread_mutexattr_destroy(&sRecursiveAttr);
		}
	}else{
		/* Use a pre-allocated static mutex */
		if( nType > SXMUTEX_TYPE_STATIC_6 ){
			nType = SXMUTEX_TYPE_STATIC_6;
		}
		pMutex = &aStaticMutexes[nType - 3];
	}
  pMutex->nType = nType;
  
  return pMutex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1, %eax
ja 0x362fa
movl $0x30, %edi
callq 0xca00
testq %rax, %rax
je 0x36321
movq %rax, %r14
cmpl $0x2, %ebx
jne 0x36326
leaq -0x1c(%rbp), %r15
movq %r15, %rdi
callq 0xcb30
movq %r15, %rdi
movl $0x1, %esi
callq 0xc610
movq %r14, %rdi
movq %r15, %rsi
callq 0xc430
movq %r15, %rdi
callq 0xc2e0
jmp 0x36330
cmpl $0x8, %ebx
movl $0x8, %eax
cmovll %ebx, %eax
leal -0x3(%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq 0x60506(%rip), %r14     # 0x96820
addq %rcx, %r14
movl %eax, %ebx
jmp 0x36330
xorl %r14d, %r14d
jmp 0x36334
movq %r14, %rdi
xorl %esi, %esi
callq 0xc430
movl %ebx, 0x28(%r14)
movq %r14, %rax
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: MemHashInit
static int MemHashInit(unqlite_kv_engine *pKvEngine,int iPageSize)
{
	mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKvEngine;
	/* Note that this instance is already zeroed */	
	/* Memory backend */
	SyMemBackendInitFromParent(&pEngine->sAlloc,unqliteExportMemBackend());
#if defined(UNQLITE_ENABLE_THREADS)
	/* Already protected by the upper layers */
	SyMemBackendDisbaleMutexing(&pEngine->sAlloc);
#endif
	/* Default hash & comparison function */
	pEngine->xHash = MemHashFunc;
	pEngine->xCmp = SyMemcmp;
	/* Allocate a new bucket */
	pEngine->apBucket = (mem_hash_record **)SyMemBackendAlloc(&pEngine->sAlloc,MEM_HASH_BUCKET_SIZE * sizeof(mem_hash_record *));
	if( pEngine->apBucket == 0 ){
		SXUNUSED(iPageSize); /* cc warning */
		return UNQLITE_NOMEM;
	}
	/* Zero the bucket */
	SyZero(pEngine->apBucket,MEM_HASH_BUCKET_SIZE * sizeof(mem_hash_record *));
	pEngine->nRecord = 0;
	pEngine->nBucket = MEM_HASH_BUCKET_SIZE;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x6032e(%rip), %rsi     # 0x966c0
movq %r14, %rdi
callq 0x36946
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x363bb
movq (%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x363b1
callq *%rax
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x38(%rbx)
leaq 0x5ec(%rip), %rax       # 0x369ae
movq %rax, 0xc0(%rbx)
leaq -0x1512(%rip), %rax     # 0x34ebe
movq %rax, 0xc8(%rbx)
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x343ed
movq %rax, 0xd8(%rbx)
testq %rax, %rax
je 0x36421
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x1fc, %rcx            # imm = 0x1FC
jb 0x363f7
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0xd0(%rbx)
xorl %eax, %eax
jmp 0x36426
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemHashConfigure
static int MemHashConfigure(unqlite_kv_engine *pKvEngine,int iOp,va_list ap)
{
	mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKvEngine;
	int rc = UNQLITE_OK;
	switch(iOp){
	case UNQLITE_KV_CONFIG_HASH_FUNC:{
		/* Use a default hash function */
		if( pEngine->nRecord > 0 ){
			rc = UNQLITE_LOCKED;
		}else{
			ProcHash xHash = va_arg(ap,ProcHash);
			if( xHash ){
				pEngine->xHash = xHash;
			}
		}
		break;
									 }
	case UNQLITE_KV_CONFIG_CMP_FUNC: {
		/* Default comparison function */
		ProcCmp xCmp = va_arg(ap,ProcCmp);
		if( xCmp ){
			pEngine->xCmp = xCmp;
		}
		break;
									 }
	default:
		/* Unknown configuration option */
		rc = UNQLITE_UNKNOWN;
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %esi
je 0x36470
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl $0x1, %esi
jne 0x364bb
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
cmpl $0x0, 0xd0(%rdi)
jne 0x364bb
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x3649c
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x364a8
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x36486
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x36492
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc8, %ecx
jmp 0x364b0
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc0, %ecx
testq %rax, %rax
je 0x364b9
movq %rax, (%rdi,%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemHashReplace
static int MemHashReplace(
	  unqlite_kv_engine *pKv,
	  const void *pKey,int nKeyLen,
	  const void *pData,unqlite_int64 nDataLen
	  )
{
	mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKv;
	mem_hash_record *pRecord;
	if( nDataLen > SXU32_HIGH ){
		/* Database limit */
		pEngine->pIo->xErr(pEngine->pIo->pHandle,"Record size limit reached");
		return UNQLITE_LIMIT;
	}
	/* Fetch the record first */
	pRecord = MemHashGetEntry(pEngine,pKey,nKeyLen);
	if( pRecord == 0 ){
		/* Allocate a new record */
		pRecord = MemHashNewRecord(pEngine,
			pKey,nKeyLen,
			pData,nDataLen,
			pEngine->xHash(pKey,nKeyLen)
			);
		if( pRecord == 0 ){
			return UNQLITE_NOMEM;
		}
		/* Link the entry */
		MemHashLinkRecord(pEngine,pRecord);
		if( (pEngine->nRecord >= pEngine->nBucket * MEM_HASH_FILL_FACTOR) && pEngine->nRecord < 100000 ){
			/* Rehash the table */
			MemHashGrowTable(pEngine);
		}
	}else{
		sxu32 nData = (sxu32)nDataLen;
		void *pNew;
		/* Replace an existing record */
		if( nData == pRecord->nDataLen ){
			/* No need to free the old chunk */
			pNew = (void *)pRecord->pData;
		}else{
			pNew = SyMemBackendAlloc(&pEngine->sAlloc,nData);
			if( pNew == 0 ){
				return UNQLITE_NOMEM;
			}
			/* Release the old data */
			SyMemBackendFree(&pEngine->sAlloc,(void *)pRecord->pData);
		}
		/* Reflect the change */
		pRecord->nDataLen = nData;
		SyMemcpy(pData,pNew,nData);
		pRecord->pData = pNew;
	}
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, %r8
jl 0x364fb
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x3f379(%rip), %rsi     # 0x75863
callq *0x80(%rax)
movl $0xfffffff9, %r14d      # imm = 0xFFFFFFF9
jmp 0x365c8
movq %r8, %r14
movl %edx, %r13d
movq %rsi, %r15
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x36a20
testq %rax, %rax
je 0x36525
movq %rax, %r12
cmpl %r14d, 0x28(%rax)
jne 0x36580
movq 0x20(%r12), %r15
jmp 0x365a4
movq %r15, %rdi
movl %r13d, %esi
callq *0xc0(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movq -0x30(%rbp), %rcx
movq %r14, %r8
movl %eax, %r9d
callq 0x36aa0
testq %rax, %rax
je 0x365c2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36b7c
movl 0xd0(%rbx), %eax
xorl %r14d, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
ja 0x365c8
movl 0xd4(%rbx), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jb 0x365c8
movq %rbx, %rdi
callq 0x36be6
jmp 0x365c8
addq $0x8, %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x343ed
testq %rax, %rax
je 0x365c2
movq %rax, %r15
movq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x3503f
movl %r14d, 0x28(%r12)
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x34fc5
movq %r15, 0x20(%r12)
xorl %r14d, %r14d
jmp 0x365c8
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %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: MemHashCursorDelete
static int MemHashCursorDelete(unqlite_kv_cursor *pCursor)
{
	mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
	mem_hash_record *pNext;
	if( pMem->pCur == 0 ){
		/* Cursor does not point to anything */
		return UNQLITE_NOTFOUND;
	}
	pNext = pMem->pCur->pPrev;
	/* Perform the deletion */
	MemHashUnlinkRecord(pMem->pCur->pEngine,pMem->pCur);
	/* Point to the next entry */
	pMem->pCur = pNext;
	return UNQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x36806
movq %rdi, %rbx
movq (%r14), %r15
movq 0x38(%r14), %r12
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x36810
movq 0x40(%r14), %rcx
movq %rcx, 0x40(%rax)
jmp 0x3682c
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x368ae
movl 0xd4(%r15), %eax
decl %eax
andl 0x8(%r14), %eax
movq 0x40(%r14), %rcx
movq 0xd8(%r15), %rdx
movq %rcx, (%rdx,%rax,8)
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x3683d
movq 0x48(%r14), %rcx
movq %rcx, 0x48(%rax)
movq 0xe8(%r15), %rax
cmpq %r14, %rax
jne 0x36854
movq 0x30(%rax), %rax
movq %rax, 0xe8(%r15)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x36865
movq 0x30(%r14), %rcx
movq %rcx, 0x30(%rax)
movq 0x30(%r14), %rcx
testq %rcx, %rcx
je 0x36872
movq %rax, 0x38(%rcx)
cmpq %r14, 0xe0(%r15)
jne 0x36886
movq 0x38(%r14), %rax
movq %rax, 0xe0(%r15)
decl 0xd0(%r15)
addq $0x8, %r15
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x3503f
movq %r15, %rdi
movq %r14, %rsi
callq 0x3503f
movq %r12, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendInitFromParent
JX9_PRIVATE sxi32 SyMemBackendInitFromParent(SyMemBackend *pBackend,const SyMemBackend *pParent)
{
	sxu8 bInheritMutex;
#if defined(UNTRUST)
	if( pBackend == 0 || SXMEM_BACKEND_CORRUPT(pParent) ){
		return SXERR_CORRUPT;
	}
#endif
	/* Zero the allocator first */
	SyZero(&(*pBackend), sizeof(SyMemBackend));
	pBackend->pMethods  = pParent->pMethods;
	pBackend->xMemError = pParent->xMemError;
	pBackend->pUserData = pParent->pUserData;
	bInheritMutex = pParent->pMutexMethods ? TRUE : FALSE;
	if( bInheritMutex ){
		pBackend->pMutexMethods = pParent->pMutexMethods;
		/* Create a private mutex */
		pBackend->pMutex = pBackend->pMutexMethods->xNew(SXMUTEX_TYPE_FAST);
		if( pBackend->pMutex ==  0){
			return SXERR_OS;
		}
	}
#if defined(UNTRUST)
	pBackend->nMagic = SXMEM_BACKEND_MAGIC;
#endif
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $-0x4, %rax
movl $0x0, 0x4(%rbx,%rax)
addq $0x4, %rax
cmpq $0xb4, %rax
jb 0x36956
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rbx)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rbx)
movq (%rsi), %rax
testq %rax, %rax
je 0x3699e
movq %rax, (%rbx)
movl $0x1, %edi
callq *0x10(%rax)
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x369a2
xorl %eax, %eax
jmp 0x369a7
movl $0xffffffe9, %eax       # imm = 0xFFFFFFE9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemHashFunc
static sxu32 MemHashFunc(const void *pSrc,sxu32 nLen)
{
	register unsigned char *zIn = (unsigned char *)pSrc;
	unsigned char *zEnd;
	sxu32 nH = 5381;
	zEnd = &zIn[nLen];
	for(;;){
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
		if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
	}	
	return nH;
}

// Assembly:
testl %esi, %esi
je 0x36a12
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
addq %rdi, %rcx
movl $0x1505, %eax           # imm = 0x1505
movl %eax, %edx
shll $0x5, %edx
addl %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x36a1e
movl %eax, %esi
shll $0x5, %esi
movzbl (%rdi), %edx
addl %eax, %edx
addl %esi, %edx
incq %rdi
cmpq %rcx, %rdi
jae 0x36a18
movl %edx, %eax
shll $0x5, %eax
movzbl (%rdi), %esi
addl %edx, %esi
addl %eax, %esi
incq %rdi
cmpq %rcx, %rdi
jae 0x36a1c
movl %esi, %edx
shll $0x5, %edx
movzbl (%rdi), %eax
addl %esi, %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jb 0x369c0
jmp 0x36a1e
movl $0x1505, %eax           # imm = 0x1505
retq
movl %edx, %eax
jmp 0x36a1e
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemHashGetEntry
static mem_hash_record * MemHashGetEntry(
	mem_hash_kv_engine *pEngine,
	const void *pKey,int nKeyLen
	)
{
	mem_hash_record *pEntry;
	sxu32 nHash,nBucket;
	/* Hash the entry */
	nHash = pEngine->xHash(pKey,(sxu32)nKeyLen);
	nBucket = nHash & (pEngine->nBucket - 1);
	pEntry = pEngine->apBucket[nBucket];
	for(;;){
		if( pEntry == 0 ){
			break;
		}
		if( pEntry->nHash == nHash && pEntry->nKeyLen == (sxu32)nKeyLen && 
			pEngine->xCmp(pEntry->pKey,pKey,pEntry->nKeyLen) == 0 ){
				return pEntry;
		}
		pEntry = pEntry->pNextHash;
	}
	/* No such entry */
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
callq *0xc0(%r15)
movl %eax, %r13d
movl 0xd4(%r15), %eax
decl %eax
andl %r13d, %eax
movq 0xd8(%r15), %rcx
movq (%rcx,%rax,8), %r12
testq %r12, %r12
je 0x36a8b
cmpl %r13d, 0x8(%r12)
jne 0x36a84
movl 0x18(%r12), %edx
cmpl %ebx, %edx
jne 0x36a84
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq *0xc8(%r15)
testl %eax, %eax
je 0x36a8e
movq 0x40(%r12), %r12
jmp 0x36a5c
xorl %r12d, %r12d
movq %r12, %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: MemHashNewRecord
static mem_hash_record * MemHashNewRecord(
	mem_hash_kv_engine *pEngine,
	const void *pKey,int nKey,
	const void *pData,unqlite_int64 nData,
	sxu32 nHash
	)
{
	SyMemBackend *pAlloc = &pEngine->sAlloc;
	mem_hash_record *pRecord;
	void *pDupData;
	sxu32 nByte;
	char *zPtr;
	
	/* Total number of bytes to alloc */
	nByte = sizeof(mem_hash_record) + nKey;
	/* Allocate a new instance */
	pRecord = (mem_hash_record *)SyMemBackendAlloc(pAlloc,nByte);
	if( pRecord == 0 ){
		return 0;
	}
	pDupData = (void *)SyMemBackendAlloc(pAlloc,(sxu32)nData);
	if( pDupData == 0 ){
		SyMemBackendFree(pAlloc,pRecord);
		return 0;
	}
	zPtr = (char *)pRecord;
	zPtr += sizeof(mem_hash_record);
	/* Zero the structure */
	SyZero(pRecord,sizeof(mem_hash_record));
	/* Fill in the structure */
	pRecord->pEngine = pEngine;
	pRecord->nDataLen = (sxu32)nData;
	pRecord->nKeyLen = (sxu32)nKey;
	pRecord->nHash = nHash;
	SyMemcpy(pKey,zPtr,pRecord->nKeyLen);
	pRecord->pKey = (const void *)zPtr;
	SyMemcpy(pData,pDupData,pRecord->nDataLen);
	pRecord->pData = pDupData;
	/* All done */
	return pRecord;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, %r12
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
leaq 0x8(%rdi), %r14
leal 0x50(%r15), %esi
movq %r14, %rdi
callq 0x343ed
testq %rax, %rax
je 0x36b68
movq %rax, %rbx
movq %r13, -0x40(%rbp)
movq %r14, %rdi
movq %r12, -0x38(%rbp)
movl %r12d, %esi
callq 0x343ed
testq %rax, %rax
je 0x36b5d
movq %rax, %r13
movq %rbx, %r14
addq $0x50, %r14
movq $-0x4, %rax
movl $0x0, 0x4(%rbx,%rax)
addq $0x4, %rax
cmpq $0x4c, %rax
jb 0x36b0b
movq -0x48(%rbp), %rax
movq %rax, (%rbx)
movq -0x38(%rbp), %rax
movl %eax, 0x28(%rbx)
movl %r15d, 0x18(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x8(%rbx)
movq -0x50(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x34fc5
movq %r14, 0x10(%rbx)
movl 0x28(%rbx), %edx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x34fc5
movq %r13, 0x20(%rbx)
jmp 0x36b6a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3503f
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_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemHashLinkRecord
static void MemHashLinkRecord(mem_hash_kv_engine *pEngine,mem_hash_record *pRecord)
{
	sxu32 nBucket = pRecord->nHash & (pEngine->nBucket - 1);
	pRecord->pNextHash = pEngine->apBucket[nBucket];
	if( pEngine->apBucket[nBucket] ){
		pEngine->apBucket[nBucket]->pPrevHash = pRecord;
	}
	pEngine->apBucket[nBucket] = pRecord;
	if( pEngine->pFirst == 0 ){
		pEngine->pFirst = pEngine->pLast = pRecord;
	}else{
		MACRO_LD_PUSH(pEngine->pLast,pRecord);
	}
	pEngine->nRecord++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xd4(%rdi), %eax
decl %eax
andl 0x8(%rsi), %eax
movq 0xd8(%rdi), %rcx
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x40(%rsi)
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je 0x36ba7
movq %rsi, 0x48(%rdx)
movq %rsi, (%rcx,%rax,8)
leaq 0xe8(%rdi), %rax
cmpq $0x0, 0xe0(%rdi)
je 0x36bce
movq (%rax), %rcx
testq %rcx, %rcx
je 0x36bdb
movq %rcx, 0x30(%rsi)
addq $0x38, %rcx
jmp 0x36bd8
movq %rax, %rcx
leaq 0xe0(%rdi), %rax
movq %rsi, (%rcx)
movq %rsi, (%rax)
incl 0xd0(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhash_kv_init
static int lhash_kv_init(unqlite_kv_engine *pEngine,int iPageSize)
{
	lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
	int rc;

	/* This structure is always zeroed, go to the initialization directly */
	SyMemBackendInitFromParent(&pHash->sAllocator,unqliteExportMemBackend());
#if defined(UNQLITE_ENABLE_THREADS)
	/* Already protected by the upper layers */
	SyMemBackendDisbaleMutexing(&pHash->sAllocator);
#endif
	pHash->iPageSize = iPageSize;
	/* Default hash function */
	pHash->xHash = lhash_bin_hash;
	/* Default comparison function */
	pHash->xCmp = SyMemcmp;
	/* Allocate a new record map */
	pHash->nBuckSize = 32;
	pHash->apMap = (lhash_bmap_rec **)SyMemBackendAlloc(&pHash->sAllocator,pHash->nBuckSize *sizeof(lhash_bmap_rec *));
	if( pHash->apMap == 0 ){
		rc = UNQLITE_NOMEM;
		goto err;
	}
	/* Zero the table */
	SyZero(pHash->apMap,pHash->nBuckSize * sizeof(lhash_bmap_rec *));
	/* Linear hashing components */
	pHash->split_bucket = 0; /* Logical not real bucket number */
	pHash->max_split_bucket = 1;
	pHash->nmax_split_nucket = 2;
	pHash->nMagic = L_HASH_MAGIC;
	/* Install the cache unpin and reload callbacks */
	pHash->pIo->xSetUnpin(pHash->pIo->pHandle,lhash_page_release);
	pHash->pIo->xSetReload(pHash->pIo->pHandle,lhash_page_release);
	return UNQLITE_OK;
err:
	SyMemBackendRelease(&pHash->sAllocator);
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x5f93c(%rip), %rsi     # 0x966c0
movq %r14, %rdi
callq 0x36946
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x36dad
movq (%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x36da3
callq *%rax
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x38(%rbx)
movl %r15d, 0x110(%rbx)
leaq 0x814(%rip), %rax       # 0x375cf
movq %rax, 0xc0(%rbx)
leaq -0x1f0b(%rip), %rax     # 0x34ebe
movq %rax, 0xc8(%rbx)
movl $0x20, 0xe4(%rbx)
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x343ed
movq %rax, 0xd8(%rbx)
testq %rax, %rax
je 0x36e81
movl 0xe4(%rbx), %ecx
shll $0x3, %ecx
testl %ecx, %ecx
je 0x36e33
addq %rax, %rcx
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jae 0x36e33
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jae 0x36e33
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jae 0x36e33
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jb 0x36e07
movq $0x0, 0x120(%rbx)
movq $0x1, 0x128(%rbx)
movq $0x2, 0x130(%rbx)
movl $0xfa782dcb, 0x138(%rbx) # imm = 0xFA782DCB
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x7de(%rip), %r14       # 0x37649
movq %r14, %rsi
callq *0x70(%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq *0x78(%rax)
xorl %eax, %eax
jmp 0x36e8e
movq %r14, %rdi
callq 0x2ea67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
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: lhash_kv_config
static int lhash_kv_config(unqlite_kv_engine *pEngine,int op,va_list ap)
{
	lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
	int rc = UNQLITE_OK;
	switch(op){
	case UNQLITE_KV_CONFIG_HASH_FUNC: {
		/* Default hash function */
		if( pHash->nBuckRec > 0 ){
			/* Locked operation */
			rc = UNQLITE_LOCKED;
		}else{
			ProcHash xHash = va_arg(ap,ProcHash);
			if( xHash ){
				pHash->xHash = xHash;
			}
		}
		break;
									  }
	case UNQLITE_KV_CONFIG_CMP_FUNC: {
		/* Default comparison function */
		ProcCmp xCmp = va_arg(ap,ProcCmp);
		if( xCmp ){
			pHash->xCmp  = xCmp;
		}
		break;
									 }
	default:
		/* Unknown OP */
		rc = UNQLITE_UNKNOWN;
		break;
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %esi
je 0x36ede
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl $0x1, %esi
jne 0x36f29
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
cmpl $0x0, 0xe0(%rdi)
jne 0x36f29
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x36f0a
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x36f16
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x36ef4
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x36f00
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc8, %ecx
jmp 0x36f1e
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc0, %ecx
testq %rax, %rax
je 0x36f27
movq %rax, (%rdi,%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: lhInitCursor
static void lhInitCursor(unqlite_kv_cursor *pPtr)
{
	 lhash_kv_engine *pEngine = (lhash_kv_engine *)pPtr->pStore;
	 lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
	 /* Init */
	 pCur->iState = L_HASH_CURSOR_STATE_NEXT_PAGE;
	 pCur->pCell = 0;
	 pCur->pRec = pEngine->pFirst;
	 pCur->pRaw = 0;
	 pCur->is_first = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl $0x1, %ecx
movl %ecx, 0x8(%rdi)
xorl %edx, %edx
movq %rdx, 0x10(%rdi)
movq 0xf0(%rax), %rax
movq %rax, 0x20(%rdi)
movq %rdx, 0x18(%rdi)
movl %ecx, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r12d
movq %rsi, %r14
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 0x37231
movl %eax, %r15d
testl %r15d, %r15d
je 0x3729a
movq $0x0, 0x10(%rbx)
movl $0x3, %ecx
movl %r15d, %eax
jmp 0x372a1
movq %r14, %rdi
movl %r12d, %esi
callq *0xc0(%r13)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl 0x130(%r13), %edx
addl %ecx, %edx
andl %eax, %edx
movq 0x128(%r13), %rdi
movq 0x120(%r13), %rsi
addq %rdi, %rsi
addl %ecx, %edi
andl %eax, %edi
cmpq %rsi, %rdx
cmovbq %rdx, %rdi
cmpl $0x0, 0xe0(%r13)
je 0x372b3
movq 0xd8(%r13), %rcx
movl 0xe4(%r13), %edx
decl %edx
andl %edi, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0x372b3
cmpq %rdi, (%rcx)
je 0x372b5
movq 0x20(%rcx), %rcx
jmp 0x3728a
movl $0x2, %ecx
xorl %eax, %eax
movl %ecx, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
movl $0xfffffffa, %r15d      # imm = 0xFFFFFFFA
testq %rcx, %rcx
je 0x3721a
movl %eax, -0x2c(%rbp)
movq 0x8(%rcx), %rsi
leaq -0x38(%rbp), %rcx
movq %r13, %rdi
xorl %edx, %edx
callq 0x38b86
testl %eax, %eax
jne 0x37217
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movl %r12d, %edx
movl -0x2c(%rbp), %ecx
callq 0x38e3c
testq %rax, %rax
je 0x3721a
movq %rax, 0x10(%rbx)
xorl %r15d, %r15d
jmp 0x3721a