LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendAlloc
JX9_PRIVATE void * SyMemBackendAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
	void *pChunk;
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) ){
		return 0;
	}
#endif
	if( pBackend->pMutexMethods ){
		SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
	}
	pChunk = MemBackendAlloc(&(*pBackend), nByte);
	if( pBackend->pMutexMethods ){
		SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
	}
	return pChunk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2ca3a
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca3a
callq *0x20(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2c2f8
movq %rax, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x2ca5c
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca5c
callq *0x30(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
testl %ecx, %ecx
jne 0x2ca85
movq %r14, %rdi
callq 0x28e24
movl %eax, %ecx
decl %r15d
addq %rbx, %r15
movl %ecx, %ecx
leaq -0x3(%rcx), %rdx
leaq -0x2(%rcx), %rsi
leaq -0x1(%rcx), %rdi
xorl %r8d, %r8d
leaq (%rbx,%r8), %rax
cmpq %r15, %rax
jae 0x2cb07
cmpl %r8d, %ecx
je 0x2cb07
movb (%r14,%r8), %r9b
leaq (%rbx,%r8), %rax
incq %rax
movb %r9b, -0x1(%rax)
cmpq %r15, %rax
jae 0x2cb07
cmpl %r8d, %edi
je 0x2cb07
movb 0x1(%r14,%r8), %r9b
leaq (%rbx,%r8), %rax
addq $0x2, %rax
movb %r9b, -0x1(%rax)
cmpq %r15, %rax
jae 0x2cb07
cmpl %r8d, %esi
je 0x2cb07
movb 0x2(%r14,%r8), %r9b
leaq (%rbx,%r8), %rax
addq $0x3, %rax
movb %r9b, -0x1(%rax)
cmpq %r15, %rax
jae 0x2cb07
cmpl %r8d, %edx
je 0x2cb07
movb 0x3(%r14,%r8), %r9b
movb %r9b, (%rax)
addq $0x4, %r8
jmp 0x2ca9c
movb $0x0, (%rax)
subl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x2cbce
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2d03b
callq 0x2c9e3
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x2cb9b
cmpl $0x0, 0x1c(%r14)
je 0x2cb5f
movq 0x28(%rbx), %rax
movq 0x20(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x20(%r14)
orl $-0x1, 0x10(%rbx)
andq $0x0, 0x28(%rbx)
decl 0x18(%r14)
jne 0x2cb9b
movq %rbx, %rdi
callq 0x2d245
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
leaq 0x28(%rcx), %rdx
testq %rcx, %rcx
leaq 0x5b575(%rip), %rsi     # 0x880f8
cmovneq %rdx, %rsi
movq %rax, (%rsi)
testq %rax, %rax
je 0x2cb93
movq %rcx, 0x30(%rax)
movq %r14, %rdi
callq 0x2c9cf
movl 0x14(%rbx), %edi
testl %edi, %edi
js 0x2cbaf
callq 0xc2b0
testl %eax, %eax
jne 0x2cbbf
orl $-0x1, 0x14(%rbx)
movl 0x10(%rbx), %edi
testl %edi, %edi
js 0x2cbd2
callq 0xc2b0
testl %eax, %eax
je 0x2cbd2
callq 0xcb50
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
pushq $-0x2
popq %rbx
jmp 0x2cbe8
xorl %ebx, %ebx
jmp 0x2cbed
movq 0x28(%rbx), %rdi
callq 0x2c9cf
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x27aea
xorl %ebx, %ebx
callq 0x2c9fe
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x10(%rdi), %edi
xorl %r13d, %r13d
movq %rcx, %rsi
xorl %edx, %edx
callq 0xc340
cmpq %r12, %rax
jne 0x2cc3c
movl 0x10(%r15), %edi
movslq %ebx, %rdx
movq %r14, %rsi
callq 0xc8a0
movq %rax, %r12
testl %r12d, %r12d
jns 0x2cc52
jmp 0x2cc46
pushq $-0x1
popq %r12
cmpq $-0x1, %rax
jne 0x2cc4e
callq 0xcb50
movl (%rax), %r13d
movl %r13d, 0x1c(%r15)
xorl %r13d, %r13d
subl %r12d, %ebx
je 0x2cc78
pushq $-0x2
popq %r13
testl %r12d, %r12d
js 0x2cc78
andl $0x0, 0x1c(%r15)
movl %r12d, %eax
addq %rax, %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x27aea
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
pushq $-0x2
popq %r14
testq %r12, %r12
jle 0x2cce3
movl 0x10(%rbx), %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0xc340
cmpq %r15, %rax
jne 0x2cce7
movl 0x10(%rbx), %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0xcb80
testl %eax, %eax
js 0x2ccf1
je 0x2ccfa
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
subq %rax, %r12
addq %rax, %r15
addq %rax, %r13
jmp 0x2cca8
xorl %eax, %eax
jmp 0x2cd06
cmpq $-0x1, %rax
je 0x2ccf1
xorl %eax, %eax
jmp 0x2cd00
callq 0xcb50
movl (%rax), %eax
jmp 0x2cd00
xorl %eax, %eax
pushq $-0x49
popq %r14
movl %eax, 0x1c(%rbx)
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_O2/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 0xcd50
testl %eax, %eax
je 0x2cd39
callq 0xcb50
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
pushq $-0x2
popq %rax
jmp 0x2cd3b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc9e0
testl %eax, %eax
je 0x2cdc7
callq 0xcb50
movl (%rax), %eax
movl %eax, 0x1c(%r14)
pushq $-0x2
popq %rax
jmp 0x2cddd
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_O2/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
callq 0x2c9e3
movq 0x8(%r15), %rax
cmpl $0x1, 0x14(%rax)
jg 0x2d1ff
leaq -0x40(%rbp), %rdx
movq $0x40000001, 0x8(%rdx)  # imm = 0x40000001
movq $0x1, 0x10(%rdx)
movl $0x1, (%rdx)
movl 0x10(%r15), %edi
xorl %r14d, %r14d
pushq $0x5
popq %rsi
xorl %eax, %eax
callq 0xc1d0
cmpl $-0x1, %eax
je 0x2d208
xorl %r15d, %r15d
cmpw $0x2, -0x40(%rbp)
setne %r15b
jmp 0x2d222
xorl %r14d, %r14d
pushq $0x1
popq %r15
jmp 0x2d222
callq 0xcb50
movl (%rax), %r12d
movl %r12d, %edi
callq 0x2d2bb
movl %eax, %r14d
movl %r12d, 0x1c(%r15)
xorl %r15d, %r15d
callq 0x2c9fe
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_O2/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 %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
movq %r12, %r15
testq %r12, %r12
je 0x2d2a1
movq 0x8(%r15), %r12
movl (%r15), %edi
callq 0xc2b0
testl %eax, %eax
jne 0x2d28a
movq %r15, %rdi
callq 0x2c9cf
jmp 0x2d268
callq 0xcb50
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movq %r13, 0x8(%r15)
movq %r15, %r13
pushq $-0x2
popq %r14
jmp 0x2d268
movq -0x30(%rbp), %rax
movq %r13, 0x20(%rax)
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_O2/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 0x2d335
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x2d338
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 %rbx
movl %edx, %ecx
leaq -0x3(%rcx), %rdx
leaq -0x2(%rcx), %r8
leaq -0x1(%rcx), %r9
xorl %eax, %eax
xorl %r10d, %r10d
cmpl %r10d, %ecx
je 0x2d3ad
movb (%rdi,%r10), %r11b
movb (%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x2d3a4
cmpl %r10d, %r9d
je 0x2d3ad
movb 0x1(%rdi,%r10), %r11b
movb 0x1(%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x2d3a4
cmpl %r10d, %r8d
je 0x2d3ad
movb 0x2(%rdi,%r10), %r11b
movb 0x2(%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x2d3a4
cmpl %r10d, %edx
je 0x2d3ad
movb 0x3(%rdi,%r10), %r11b
movb 0x3(%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x2d3a4
addq $0x4, %r10
jmp 0x2d350
movzbl %r11b, %eax
movzbl %bl, %ecx
subl %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d469
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2d446
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2d446
callq *0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d46e
movq (%rbx), %rax
testq %rax, %rax
je 0x2d469
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2d469
popq %rbx
popq %r14
popq %rbp
jmpq *0x30(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d4b6
leaq -0x10(%rsi), %rax
movq 0x10(%rdi), %rdx
cmpq %rax, %rdx
jne 0x2d48d
movq (%rdx), %rdx
movq %rdx, 0x10(%rdi)
movq -0x10(%rsi), %rdx
movq -0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x2d49d
movq %rdx, (%rsi)
testq %rdx, %rdx
je 0x2d4a6
movq %rsi, 0x8(%rdx)
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_O2/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
leaq -0x100(%rbp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x2d50c
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)
andl $0x0, 0x10(%rbx)
andq $0x0, (%rbx)
movq %rdx, %r9
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 %r10, 0x10(%rcx)
movq %rcx, (%rsp)
pushq $0x6
popq %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2d586
movl 0x10(%rbx), %r14d
incl 0x14(%rbx)
leaq 0x35648(%rip), %rsi     # 0x62bb4
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2e250
movl %r14d, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
testl %edx, %edx
je 0x2e3be
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r12
movl 0x18(%rdi), %eax
testb $0x3, %al
je 0x2e2a4
movl 0x10(%r12), %eax
movl 0x14(%r12), %ecx
movl %ecx, %edx
subl %eax, %edx
cmpl %r15d, %edx
jae 0x2e349
movl %edx, %r15d
cmpl %eax, %ecx
jne 0x2e349
pushq $-0x1d
popq %r14
jmp 0x2e3be
pushq $-0x1
popq %r14
testb $0x4, %al
jne 0x2e2b8
movl 0x10(%r12), %ecx
movl 0x14(%r12), %eax
jmp 0x2e306
movl 0x10(%r12), %edx
testl %edx, %edx
je 0x2e2ee
movq (%r12), %rdi
movq 0x8(%r12), %rsi
callq 0x2e418
testq %rax, %rax
je 0x2e3be
movq %rax, 0x8(%r12)
movl 0x10(%r12), %ecx
movl 0x18(%r12), %eax
movl %ecx, 0x14(%r12)
jmp 0x2e2fc
andq $0x0, 0x8(%r12)
andl $0x0, 0x14(%r12)
xorl %ecx, %ecx
andl $-0x5, %eax
movl %eax, 0x18(%r12)
movl %ecx, %eax
movl %eax, %edx
subl %ecx, %edx
cmpl %r15d, %edx
jae 0x2e349
testl %eax, %eax
je 0x2e31d
leal (%r15,%rax,2), %r13d
addl $0x10, %r13d
jmp 0x2e329
cmpl $0x11, %r15d
pushq $0x10
popq %r13
cmovael %r15d, %r13d
movq (%r12), %rdi
movq 0x8(%r12), %rsi
movl %r13d, %edx
callq 0x2c218
testq %rax, %rax
je 0x2e3be
movq %rax, 0x8(%r12)
movl %r13d, 0x14(%r12)
movl $0x0, %r14d
testq %rbx, %rbx
je 0x2e3be
movl 0x10(%r12), %ecx
movq %rcx, %rax
addq 0x8(%r12), %rax
addl %r15d, %ecx
movl %ecx, 0x10(%r12)
movl %r15d, %ecx
leaq -0x3(%rcx), %rdx
leaq -0x2(%rcx), %rsi
leaq -0x1(%rcx), %rdi
xorl %r14d, %r14d
xorl %r8d, %r8d
cmpl %r8d, %ecx
je 0x2e3be
movb (%rbx,%r8), %r9b
movb %r9b, (%rax,%r8)
cmpl %r8d, %edi
je 0x2e3be
movb 0x1(%rbx,%r8), %r9b
movb %r9b, 0x1(%rax,%r8)
cmpl %r8d, %esi
je 0x2e3be
movb 0x2(%rbx,%r8), %r9b
movb %r9b, 0x2(%rax,%r8)
cmpl %r8d, %edx
je 0x2e3be
movb 0x3(%rbx,%r8), %r9b
movb %r9b, 0x3(%rax,%r8)
addq $0x4, %r8
jmp 0x2e37e
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_O2/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), %eax
cmpl $0x6, %eax
je 0x2e3fc
cmpl $0x1, %eax
jne 0x2e40a
movq 0x18(%rbx), %rdx
movq %rsi, %rdi
movl %r14d, %esi
callq *0x10(%rbx)
jmp 0x2e40d
movq 0x10(%rbx), %rdi
movl %r14d, %edx
callq 0x2e250
jmp 0x2e40d
pushq $-0xa
popq %rax
addl %r14d, (%rbx)
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ca19
movq %rax, %r15
testq %rax, %rax
je 0x2e443
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x2d3b0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e4a6
pushq $0x30
popq %rdi
callq 0xca30
testq %rax, %rax
je 0x2e4c7
movq %rax, %r14
cmpl $0x2, %ebx
jne 0x2e4cc
leaq -0x1c(%rbp), %r15
movq %r15, %rdi
callq 0xcb60
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xc620
movq %r14, %rdi
movq %r15, %rsi
callq 0xc430
movq %r15, %rdi
callq 0xc2e0
jmp 0x2e4d6
cmpl $0x8, %ebx
pushq $0x8
popq %rax
cmovll %ebx, %eax
leal -0x3(%rax), %ecx
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
leaq 0x59380(%rip), %r14     # 0x87840
addq %rcx, %r14
movl %eax, %ebx
jmp 0x2e4d6
xorl %r14d, %r14d
jmp 0x2e4da
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_O2/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 0x591a8(%rip), %rsi     # 0x876e0
movq %r14, %rdi
callq 0x2eaa1
movq %r14, %rdi
callq 0x2eaf6
leaq 0x5d7(%rip), %rax       # 0x2eb26
movq %rax, 0xc0(%rbx)
leaq -0x124f(%rip), %rax     # 0x2d30e
movq %rax, 0xc8(%rbx)
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2ca19
movq %rax, 0xd8(%rbx)
testq %rax, %rax
je 0x2e59f
movq %rax, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x27aea
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0xd0(%rbx)
xorl %eax, %eax
jmp 0x2e5a2
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e5d3
cmpl $0x1, %esi
jne 0x2e5e9
cmpl $0x0, 0xd0(%rdi)
je 0x2e606
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x2e63b
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x2e5f0
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x2e5fc
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
jmp 0x2e63b
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc8, %ecx
jmp 0x2e630
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x2e61c
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x2e628
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc0, %ecx
testq %rax, %rax
je 0x2e639
movq %rax, (%rdi,%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e677
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x351e1(%rip), %rsi     # 0x6384b
callq *0x80(%rax)
pushq $-0x7
jmp 0x2e740
movq %r8, %r14
movl %edx, %r13d
movq %rsi, %r15
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x2eb78
testq %rax, %rax
je 0x2e6a1
movq %rax, %r12
cmpl %r14d, 0x28(%rax)
jne 0x2e6fc
movq 0x20(%r12), %r15
jmp 0x2e720
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 0x2ebf9
testq %rax, %rax
je 0x2e73e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ecbc
movl 0xd0(%rbx), %eax
xorl %r14d, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
ja 0x2e742
movl 0xd4(%rbx), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jb 0x2e742
movq %rbx, %rdi
callq 0x2ed22
jmp 0x2e742
addq $0x8, %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2ca19
testq %rax, %rax
je 0x2e73e
movq %rax, %r15
movq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x2d420
movl %r14d, 0x28(%r12)
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x2d3b0
movq %r15, 0x20(%r12)
xorl %r14d, %r14d
jmp 0x2e742
pushq $-0x1
popq %r14
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_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: MemHashAppend
static int MemHashAppend(
	  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 * MEM_HASH_FILL_FACTOR >= pEngine->nBucket && pEngine->nRecord < 100000 ){
			/* Rehash the table */
			MemHashGrowTable(pEngine);
		}
	}else{
		unqlite_int64 nNew = pRecord->nDataLen + nDataLen;
		void *pOld = (void *)pRecord->pData;
		sxu32 nData;
		char *zNew;
		/* Append data to the existing record */
		if( nNew > SXU32_HIGH ){
			/* Overflow */
			pEngine->pIo->xErr(pEngine->pIo->pHandle,"Append operation will cause data overflow");	
			return UNQLITE_LIMIT;
		}
		nData = (sxu32)nNew;
		/* Allocate bigger chunk */
		zNew = (char *)SyMemBackendRealloc(&pEngine->sAlloc,pOld,nData);
		if( zNew == 0 ){
			return UNQLITE_NOMEM;
		}
		/* Reflect the change */
		SyMemcpy(pData,&zNew[pRecord->nDataLen],(sxu32)nDataLen);
		pRecord->pData = (const void *)zNew;
		pRecord->nDataLen = nData;
	}
	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 0x2e783
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x350ca(%rip), %rsi     # 0x6384b
jmp 0x2e7c7
movq %r8, %r14
movl %edx, %r13d
movq %rsi, %r15
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x2eb78
testq %rax, %rax
je 0x2e7e3
movq %rax, %r12
movl 0x28(%rax), %r13d
addq %r14, %r13
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, %r13
jl 0x2e83c
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x3509e(%rip), %rsi     # 0x63865
callq *0x80(%rax)
pushq $-0x7
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
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 0x2ebf9
testq %rax, %rax
je 0x2e87e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ecbc
movl 0xd0(%rbx), %eax
xorl %r14d, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
ja 0x2e7d1
shll $0x2, %eax
cmpl 0xd4(%rbx), %eax
jb 0x2e7d1
movq %rbx, %rdi
callq 0x2ed22
jmp 0x2e7d1
movq 0x20(%r12), %rsi
addq $0x8, %rbx
movq %rbx, %rdi
movl %r13d, %edx
callq 0x2c218
testq %rax, %rax
je 0x2e87e
movq %rax, %rbx
movl 0x28(%r12), %esi
addq %rax, %rsi
movq -0x30(%rbp), %rdi
movl %r14d, %edx
callq 0x2d3b0
movq %rbx, 0x20(%r12)
movl %r13d, 0x28(%r12)
xorl %r14d, %r14d
jmp 0x2e7d1
pushq $-0x1
jmp 0x2e7cf
// File: /workspace/github_c_makefile_star2_O2/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 0x2e96b
movq %rdi, %rbx
movq (%r14), %r15
movq 0x38(%r14), %r12
movq 0x48(%r14), %rcx
testq %rcx, %rcx
je 0x2e973
movq 0x40(%r14), %rax
movq %rax, 0x40(%rcx)
jmp 0x2e98f
pushq $-0x6
popq %rax
jmp 0x2ea09
movl 0xd4(%r15), %ecx
decl %ecx
andl 0x8(%r14), %ecx
movq 0x40(%r14), %rax
movq 0xd8(%r15), %rdx
movq %rax, (%rdx,%rcx,8)
testq %rax, %rax
je 0x2e99c
movq 0x48(%r14), %rcx
movq %rcx, 0x48(%rax)
movq 0xe8(%r15), %rax
cmpq %r14, %rax
jne 0x2e9b3
movq 0x30(%rax), %rax
movq %rax, 0xe8(%r15)
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
testq %rcx, %rcx
je 0x2e9c4
movq %rax, 0x30(%rcx)
testq %rax, %rax
je 0x2e9cd
movq %rcx, 0x38(%rax)
cmpq %r14, 0xe0(%r15)
jne 0x2e9e1
movq 0x38(%r14), %rax
movq %rax, 0xe0(%r15)
decl 0xd0(%r15)
addq $0x8, %r15
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x2d420
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d420
movq %r12, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xb8, %esi
callq 0x27aea
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq (%r14), %rax
testq %rax, %rax
je 0x2eaea
movq %rax, (%rbx)
pushq $0x1
popq %rdi
callq *0x10(%rax)
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x2eaee
xorl %eax, %eax
jmp 0x2eaf1
pushq $-0x17
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: SyMemBackendDisbaleMutexing
JX9_PRIVATE sxi32 SyMemBackendDisbaleMutexing(SyMemBackend *pBackend)
{
#if defined(UNTRUST)
	if( SXMEM_BACKEND_CORRUPT(pBackend) ){
		return SXERR_CORRUPT;
	}
#endif
	if( pBackend->pMutex == 0 ){
		/* There is no mutex subsystem at all */
		return SXRET_OK;
	}
	SyMutexRelease(pBackend->pMutexMethods, pBackend->pMutex);
	pBackend->pMutexMethods = 0;
	pBackend->pMutex = 0; 
	return SXRET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x2eb1f
movq (%rbx), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x2eb16
callq *%rax
andq $0x0, (%rbx)
andq $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
addq %rdi, %rcx
movl $0x1505, %eax           # imm = 0x1505
cmpq %rcx, %rdi
jae 0x2eb76
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x2eb76
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x2eb76
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jae 0x2eb76
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
addl %edx, %eax
incq %rdi
jmp 0x2eb34
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r12d
decl %r12d
andl %eax, %r12d
shlq $0x3, %r12
addq 0xd8(%r15), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x2ebe7
cmpl %r13d, 0x8(%r12)
jne 0x2ebe1
cmpl %ebx, 0x18(%r12)
jne 0x2ebe1
movq 0x10(%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq *0xc8(%r15)
testl %eax, %eax
je 0x2ebe7
addq $0x40, %r12
jmp 0x2ebb5
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_O2/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, -0x38(%rbp)
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, -0x48(%rbp)
movq %rdi, %r12
leaq 0x8(%rdi), %r14
leal 0x50(%r15), %esi
movq %r14, %rdi
callq 0x2ca19
testq %rax, %rax
je 0x2eca8
movq %rax, %rbx
movq %r13, -0x40(%rbp)
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x2ca19
testq %rax, %rax
je 0x2ec9d
movq %rax, %r13
movq %rbx, %r14
addq $0x50, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x27aea
movq %r12, (%rbx)
movq -0x38(%rbp), %rax
movl %eax, 0x28(%rbx)
movl %r15d, 0x18(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x8(%rbx)
movq -0x48(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2d3b0
movq %r14, 0x10(%rbx)
movl 0x28(%rbx), %edx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x2d3b0
movq %r13, 0x20(%rbx)
jmp 0x2ecaa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d420
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_O2/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)
testq %rdx, %rdx
je 0x2ece3
movq %rsi, 0x48(%rdx)
movq %rsi, (%rcx,%rax,8)
leaq 0xe8(%rdi), %rax
cmpq $0x0, 0xe0(%rdi)
je 0x2ed0a
movq (%rax), %rcx
testq %rcx, %rcx
je 0x2ed17
movq %rcx, 0x30(%rsi)
addq $0x38, %rcx
jmp 0x2ed14
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_O2/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 0x5886d(%rip), %rsi     # 0x876e0
movq %r14, %rdi
callq 0x2eaa1
movq %r14, %rdi
callq 0x2eaf6
movl %r15d, 0x110(%rbx)
leaq 0x701(%rip), %rax       # 0x2f592
movq %rax, 0xc0(%rbx)
leaq -0x1b91(%rip), %rax     # 0x2d30e
movq %rax, 0xc8(%rbx)
movl $0x20, 0xe4(%rbx)
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2ca19
movq %rax, 0xd8(%rbx)
testq %rax, %rax
je 0x2ef25
movl 0xe4(%rbx), %esi
shll $0x3, %esi
movq %rax, %rdi
callq 0x27aea
andq $0x0, 0x120(%rbx)
movq $0x1, 0x128(%rbx)
movq $0x2, 0x130(%rbx)
movl $0xfa782dcb, 0x138(%rbx) # imm = 0xFA782DCB
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x6dd(%rip), %r14       # 0x2f5ec
movq %r14, %rsi
callq *0x70(%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq *0x78(%rax)
xorl %eax, %eax
jmp 0x2ef30
movq %r14, %rdi
callq 0x27b23
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2ef67
cmpl $0x1, %esi
jne 0x2ef7d
cmpl $0x0, 0xe0(%rdi)
je 0x2ef9a
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x2efcf
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x2ef84
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x2ef90
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
jmp 0x2efcf
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc8, %ecx
jmp 0x2efc4
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x2efb0
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x2efbc
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc0, %ecx
testq %rax, %rax
je 0x2efcd
movq %rax, (%rdi,%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq 0xf0(%rax), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x18(%rdi)
movl %ecx, 0xc(%rdi)
popq %rbp
retq