LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: openDirectory
static int openDirectory(const char *zFilename, int *pFd){
  sxu32 ii;
  int fd = -1;
  char zDirname[MAX_PATHNAME+1];
  sxu32 n;
  n = Systrcpy(zDirname,sizeof(zDirname),zFilename,0);
  for(ii=n; ii>1 && zDirname[ii]!='/'; ii--);
  if( ii>0 ){
    zDirname[ii] = '\0';
    fd = open(zDirname, O_RDONLY|O_BINARY, 0);
    if( fd>=0 ){
#ifdef FD_CLOEXEC
      fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
#endif
    }
  }
  *pFd = fd;
  return (fd>=0?UNQLITE_OK: UNQLITE_IOERR );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %rdx
leaq -0x220(%rbp), %rdi
movl $0x201, %esi            # imm = 0x201
xorl %ecx, %ecx
callq 0x33dd1
cmpl $0x2, %eax
jb 0x33d0a
movl %eax, %ecx
movl %ecx, %ecx
cmpb $0x2f, -0x220(%rbp,%rcx)
je 0x33d13
decl %ecx
cmpl $0x1, %ecx
ja 0x33cf0
movl $0x1, %ecx
jmp 0x33d13
movl $0x1, %ecx
testl %eax, %eax
je 0x33d66
movb $0x0, -0x220(%rbp,%rcx)
xorl %r14d, %r14d
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc510
movl %eax, %r15d
testl %eax, %eax
js 0x33d5e
movl %r15d, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc1b0
orl $0x1, %eax
movl %r15d, %edi
movl $0x2, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0xc1b0
jmp 0x33d72
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x33d72
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, (%rbx)
movl %r14d, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33da7
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x33da7
callq *0x20(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x335ad
movq %rax, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x33dc9
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x33dc9
callq *0x30(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33e17
cmpb $0x0, (%rdx)
movq %rdx, %rcx
je 0x33e15
leaq 0x2(%rdx), %rcx
cmpb $0x0, -0x1(%rcx)
je 0x33e0d
cmpb $0x0, (%rcx)
je 0x33e15
cmpb $0x0, 0x1(%rcx)
je 0x33e12
leaq 0x4(%rcx), %rax
cmpb $0x0, 0x2(%rcx)
movq %rax, %rcx
jne 0x33de6
addq $-0x2, %rax
movq %rax, %rcx
jmp 0x33e15
decq %rcx
jmp 0x33e15
incq %rcx
subl %edx, %ecx
movq %rdi, %rax
decl %esi
je 0x33eb5
movq %rdi, %rax
testl %ecx, %ecx
je 0x33eb5
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 0x33eb5
cmpl %r11d, %r8d
je 0x33eb5
movb 0x1(%rdx,%r11), %bl
leaq (%rdi,%r11), %rax
addq $0x2, %rax
movb %bl, -0x1(%rax)
cmpq %rsi, %rax
jae 0x33eb5
cmpl %r11d, %r9d
je 0x33eb5
movb 0x2(%rdx,%r11), %bl
leaq (%rdi,%r11), %rax
addq $0x3, %rax
movb %bl, -0x1(%rax)
cmpq %rsi, %rax
jae 0x33eb5
cmpl %r11d, %ecx
je 0x33eb5
movb 0x3(%rdx,%r11), %al
leaq (%rdi,%r11), %rbx
addq $0x4, %rbx
movb %al, -0x1(%rbx)
leaq 0x4(%r11), %rax
cmpq %rsi, %rbx
jae 0x33eb2
cmpl %r11d, %r10d
movq %rax, %r11
jne 0x33e45
addq %rdi, %rax
movb $0x0, (%rax)
subl %edi, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33f97
movq %rdi, %rbx
xorl %esi, %esi
callq 0x34478
movl $0x4, 0x60997(%rip)     # 0x94878
leaq 0x60968(%rip), %rdi     # 0x94850
callq 0xc330
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x33f5f
cmpl $0x0, 0x1c(%r14)
je 0x33f1c
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)
decl 0x18(%r14)
jne 0x33f5f
movq %rbx, %rdi
callq 0x3470c
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
leaq 0x28(%rcx), %rdx
testq %rcx, %rcx
leaq 0x61198(%rip), %rsi     # 0x950d8
cmovneq %rdx, %rsi
movq %rax, (%rsi)
testq %rax, %rax
je 0x33f50
movq %rcx, 0x30(%rax)
leaq 0x60769(%rip), %rdi     # 0x946c0
movq %r14, %rsi
callq 0x3490d
movl 0x14(%rbx), %edi
testl %edi, %edi
js 0x33f76
callq 0xc2b0
testl %eax, %eax
jne 0x33f86
movl $0xffffffff, 0x14(%rbx) # imm = 0xFFFFFFFF
movl 0x10(%rbx), %edi
testl %edi, %edi
js 0x33f9b
callq 0xc2b0
testl %eax, %eax
je 0x33f9b
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x33fc7
xorl %ebx, %ebx
jmp 0x33fdd
movq 0x28(%rbx), %rsi
leaq 0x6071a(%rip), %rdi     # 0x946c0
callq 0x3490d
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x40(%rbx)
xorl %ebx, %ebx
movl $0x4, 0x608a7(%rip)     # 0x94878
leaq 0x60878(%rip), %rdi     # 0x94850
callq 0xc2d0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3402c
movl 0x10(%r15), %edi
movslq %ebx, %rdx
movq %r14, %rsi
callq 0xc890
movq %rax, %r12
testl %r12d, %r12d
jns 0x34044
jmp 0x34038
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
jne 0x34040
callq 0xcb20
movl (%rax), %r13d
movl %r13d, 0x1c(%r15)
xorl %eax, %eax
subl %r12d, %ebx
je 0x34096
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testl %r12d, %r12d
js 0x34096
movl $0x0, 0x1c(%r15)
movl %r12d, %ecx
addq %rcx, %r14
addq %r14, %rbx
movb $0x0, (%r14)
incq %r14
cmpq %rbx, %r14
jae 0x34096
movb $0x0, (%r14)
incq %r14
cmpq %rbx, %r14
jae 0x34096
movb $0x0, (%r14)
incq %r14
cmpq %rbx, %r14
jae 0x34096
movb $0x0, (%r14)
incq %r14
cmpq %rbx, %r14
jb 0x34066
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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:
testq %rdx, %rdx
jle 0x340fb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0x10(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xc340
cmpq %r14, %rax
jne 0x340fe
movl 0x10(%rbx), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0xcb50
testl %eax, %eax
js 0x3410b
je 0x34119
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r14
addq %rax, %r12
subq %rax, %r15
jg 0x340c1
xorl %eax, %eax
jmp 0x34123
xorl %eax, %eax
retq
cmpq $-0x1, %rax
je 0x3410b
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x3411e
callq 0xcb20
movl (%rax), %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x34120
movl $0xffffffb7, %eax       # imm = 0xFFFFFFB7
xorl %ecx, %ecx
movl %ecx, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x34152
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x34154
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x341e7
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%r14)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x341fd
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_O3/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, 0x6021b(%rip)     # 0x94878
leaq 0x601ec(%rip), %rdi     # 0x94850
callq 0xc330
movq 0x8(%r15), %rax
cmpl $0x1, 0x14(%rax)
jg 0x346b3
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 0x346be
xorl %r15d, %r15d
cmpw $0x2, -0x40(%rbp)
setne %r15b
jmp 0x346d8
xorl %r14d, %r14d
movl $0x1, %r15d
jmp 0x346d8
callq 0xcb20
movl (%rax), %r12d
movl %r12d, %edi
callq 0x34799
movl %eax, %r14d
movl %r12d, 0x1c(%r15)
xorl %r15d, %r15d
movl $0x4, 0x60196(%rip)     # 0x94878
leaq 0x60167(%rip), %rdi     # 0x94850
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_O3/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 0x34779
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x8(%r12), %r14
movl (%r12), %edi
callq 0xc2b0
testl %eax, %eax
je 0x34760
callq 0xcb20
movl (%rax), %eax
movl %eax, 0x1c(%rbx)
movq %r13, 0x8(%r12)
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
movq %r12, %r13
jmp 0x3476f
leaq 0x5ff59(%rip), %rdi     # 0x946c0
movq %r12, %rsi
callq 0x3490d
movq %r14, %r12
testq %r14, %r14
jne 0x34734
jmp 0x3477f
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_O3/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 0x34818
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x3481b
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 -0x1(%rcx), %rdx
leaq -0x2(%rcx), %r8
leaq -0x3(%rcx), %r9
xorl %r10d, %r10d
xorl %eax, %eax
movb (%rdi,%r10), %r11b
movb (%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x34887
cmpl %r10d, %edx
je 0x34890
movb 0x1(%rdi,%r10), %r11b
movb 0x1(%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x34887
cmpl %r10d, %r8d
je 0x34890
movb 0x2(%rdi,%r10), %r11b
movb 0x2(%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x34887
cmpl %r10d, %r9d
je 0x34890
movb 0x3(%rdi,%r10), %r11b
movb 0x3(%rsi,%r10), %bl
cmpb %bl, %r11b
jne 0x34887
addq $0x4, %r10
cmpl %r10d, %ecx
jne 0x34833
jmp 0x34890
movzbl %r11b, %eax
movzbl %bl, %ecx
subl %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x34956
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x34933
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x34933
callq *0x20(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3495b
movq (%rbx), %rax
testq %rax, %rax
je 0x34956
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x34956
popq %rbx
popq %r14
popq %rbp
jmpq *0x30(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x349a3
leaq -0x10(%rsi), %rax
movq 0x10(%rdi), %rdx
cmpq %rax, %rdx
jne 0x3497a
movq (%rdx), %rdx
movq %rdx, 0x10(%rdi)
movq -0x10(%rsi), %rdx
movq -0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x3498a
movq %rdx, (%rsi)
testq %rdx, %rdx
je 0x34993
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_O3/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 0x349fc
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 0x34a80
movl 0x10(%rbx), %r14d
incl 0x14(%rbx)
leaq 0x3e16c(%rip), %rsi     # 0x72bd0
movq %rbx, %rdi
movl $0x1, %edx
callq 0x359ad
movl %r14d, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %edx, %edx
je 0x359f6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movl 0x18(%rdi), %eax
testb $0x3, %al
je 0x359f9
movl 0x10(%r15), %ecx
movl 0x14(%r15), %edx
movl %edx, %esi
subl %ecx, %esi
cmpl %r14d, %esi
jae 0x35a96
movl $0xffffffe3, %eax       # imm = 0xFFFFFFE3
movl %esi, %r14d
cmpl %ecx, %edx
jne 0x35a96
jmp 0x35b15
xorl %eax, %eax
retq
testb $0x4, %al
jne 0x35a07
movl 0x10(%r15), %ecx
movl 0x14(%r15), %eax
jmp 0x35a51
movl 0x10(%r15), %edx
testl %edx, %edx
je 0x35a36
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0x35b66
testq %rax, %rax
je 0x35b10
movq %rax, 0x8(%r15)
movl 0x10(%r15), %ecx
movl 0x18(%r15), %eax
movl %ecx, 0x14(%r15)
jmp 0x35a48
movq $0x0, 0x8(%r15)
movl $0x0, 0x14(%r15)
xorl %ecx, %ecx
andl $-0x5, %eax
movl %eax, 0x18(%r15)
movl %ecx, %eax
movl %eax, %edx
subl %ecx, %edx
cmpl %r14d, %edx
jae 0x35a96
testl %eax, %eax
je 0x35a68
leal (%r14,%rax,2), %r12d
addl $0x10, %r12d
jmp 0x35a76
cmpl $0x11, %r14d
movl $0x10, %r12d
cmovael %r14d, %r12d
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movl %r12d, %edx
callq 0x334b2
testq %rax, %rax
je 0x35b10
movq %rax, 0x8(%r15)
movl %r12d, 0x14(%r15)
testq %rbx, %rbx
je 0x35b0c
movq 0x8(%r15), %rcx
movl 0x10(%r15), %edx
leal (%rdx,%r14), %eax
movl %eax, 0x10(%r15)
movl $0x0, %eax
testl %r14d, %r14d
je 0x35b15
addq %rdx, %rcx
movl %r14d, %edx
leaq -0x1(%rdx), %rsi
leaq -0x2(%rdx), %rdi
leaq -0x3(%rdx), %r8
xorl %eax, %eax
xorl %r9d, %r9d
movb (%rbx,%r9), %r10b
movb %r10b, (%rcx,%r9)
cmpl %r9d, %esi
je 0x35b15
movb 0x1(%rbx,%r9), %r10b
movb %r10b, 0x1(%rcx,%r9)
cmpl %r9d, %edi
je 0x35b15
movb 0x2(%rbx,%r9), %r10b
movb %r10b, 0x2(%rcx,%r9)
cmpl %r9d, %r8d
je 0x35b15
movb 0x3(%rbx,%r9), %r10b
movb %r10b, 0x3(%rcx,%r9)
addq $0x4, %r9
cmpl %r9d, %edx
jne 0x35acc
jmp 0x35b15
xorl %eax, %eax
jmp 0x35b15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x35b4f
movl $0xfffffff6, %eax       # imm = 0xFFFFFFF6
cmpl $0x1, %ecx
jne 0x35b5b
movq 0x18(%rbx), %rdx
movq %rsi, %rdi
movl %r14d, %esi
callq *0x10(%rbx)
jmp 0x35b5b
movq 0x10(%rbx), %rdi
movl %r14d, %edx
callq 0x359ad
addl %r14d, (%rbx)
movl %eax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33d86
movq %rax, %r15
testq %rax, %rax
je 0x35b91
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x34893
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x35bf8
movl $0x30, %edi
callq 0xca00
testq %rax, %rax
je 0x35c1f
movq %rax, %r14
cmpl $0x2, %ebx
jne 0x35c24
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 0x35c2e
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 0x5ec08(%rip), %r14     # 0x94820
addq %rcx, %r14
movl %eax, %ebx
jmp 0x35c2e
xorl %r14d, %r14d
jmp 0x35c32
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_O3/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 0x5ea30(%rip), %rsi     # 0x946c0
movq %r14, %rdi
callq 0x3622f
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x35cb9
movq (%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x35caf
callq *%rax
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x38(%rbx)
leaq 0x5d7(%rip), %rax       # 0x36297
movq %rax, 0xc0(%rbx)
leaq -0x14dd(%rip), %rax     # 0x347f1
movq %rax, 0xc8(%rbx)
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x33d86
movq %rax, 0xd8(%rbx)
testq %rax, %rax
je 0x35d1f
movq $-0x4, %rcx
movl $0x0, 0x4(%rax,%rcx)
addq $0x4, %rcx
cmpq $0x1fc, %rcx            # imm = 0x1FC
jb 0x35cf5
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, 0xd0(%rbx)
xorl %eax, %eax
jmp 0x35d24
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x35d6e
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl $0x1, %esi
jne 0x35db9
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
cmpl $0x0, 0xd0(%rdi)
jne 0x35db9
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x35d9a
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x35da6
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x35d84
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x35d90
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc8, %ecx
jmp 0x35dae
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc0, %ecx
testq %rax, %rax
je 0x35db7
movq %rax, (%rdi,%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x35df9
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x3da83(%rip), %rsi     # 0x7386b
callq *0x80(%rax)
movl $0xfffffff9, %r14d      # imm = 0xFFFFFFF9
jmp 0x35ec6
movq %r8, %r14
movl %edx, %r13d
movq %rsi, %r15
movq %rcx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x36309
testq %rax, %rax
je 0x35e23
movq %rax, %r12
cmpl %r14d, 0x28(%rax)
jne 0x35e7e
movq 0x20(%r12), %r15
jmp 0x35ea2
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 0x36389
testq %rax, %rax
je 0x35ec0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36465
movl 0xd0(%rbx), %eax
xorl %r14d, %r14d
cmpl $0x1869f, %eax          # imm = 0x1869F
ja 0x35ec6
movl 0xd4(%rbx), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jb 0x35ec6
movq %rbx, %rdi
callq 0x364cb
jmp 0x35ec6
addq $0x8, %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x33d86
testq %rax, %rax
je 0x35ec0
movq %rax, %r15
movq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x3490d
movl %r14d, 0x28(%r12)
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x34893
movq %r15, 0x20(%r12)
xorl %r14d, %r14d
jmp 0x35ec6
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_O3/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 0x360f7
movq %rdi, %rbx
movq (%r14), %r15
movq 0x38(%r14), %r12
movq 0x48(%r14), %rcx
testq %rcx, %rcx
je 0x36101
movq 0x40(%r14), %rax
movq %rax, 0x40(%rcx)
jmp 0x3611d
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x36197
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 0x3612a
movq 0x48(%r14), %rcx
movq %rcx, 0x48(%rax)
movq 0xe8(%r15), %rax
cmpq %r14, %rax
jne 0x36141
movq 0x30(%rax), %rax
movq %rax, 0xe8(%r15)
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
testq %rcx, %rcx
je 0x36152
movq %rax, 0x30(%rcx)
testq %rax, %rax
je 0x3615b
movq %rcx, 0x38(%rax)
cmpq %r14, 0xe0(%r15)
jne 0x3616f
movq 0x38(%r14), %rax
movq %rax, 0xe0(%r15)
decl 0xd0(%r15)
addq $0x8, %r15
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x3490d
movq %r15, %rdi
movq %r14, %rsi
callq 0x3490d
movq %r12, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3623f
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 0x36287
movq %rax, (%rbx)
movl $0x1, %edi
callq *0x10(%rax)
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x3628b
xorl %eax, %eax
jmp 0x36290
movl $0xffffffe9, %eax       # imm = 0xFFFFFFE9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x362fb
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 0x36307
movl %eax, %esi
shll $0x5, %esi
movzbl (%rdi), %edx
addl %eax, %edx
addl %esi, %edx
incq %rdi
cmpq %rcx, %rdi
jae 0x36301
movl %edx, %eax
shll $0x5, %eax
movzbl (%rdi), %esi
addl %edx, %esi
addl %eax, %esi
incq %rdi
cmpq %rcx, %rdi
jae 0x36305
movl %esi, %edx
shll $0x5, %edx
movzbl (%rdi), %eax
addl %esi, %eax
addl %edx, %eax
incq %rdi
cmpq %rcx, %rdi
jb 0x362a9
jmp 0x36307
movl $0x1505, %eax           # imm = 0x1505
retq
movl %edx, %eax
jmp 0x36307
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x36374
cmpl %r13d, 0x8(%r12)
jne 0x3636d
cmpl %ebx, 0x18(%r12)
jne 0x3636d
movq 0x10(%r12), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq *0xc8(%r15)
testl %eax, %eax
je 0x36377
movq 0x40(%r12), %r12
jmp 0x36345
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_O3/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 0x33d86
testq %rax, %rax
je 0x36451
movq %rax, %rbx
movq %r13, -0x40(%rbp)
movq %r14, %rdi
movq %r12, -0x38(%rbp)
movl %r12d, %esi
callq 0x33d86
testq %rax, %rax
je 0x36446
movq %rax, %r13
movq %rbx, %r14
addq $0x50, %r14
movq $-0x4, %rax
movl $0x0, 0x4(%rbx,%rax)
addq $0x4, %rax
cmpq $0x4c, %rax
jb 0x363f4
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 0x34893
movq %r14, 0x10(%rbx)
movl 0x28(%rbx), %edx
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x34893
movq %r13, 0x20(%rbx)
jmp 0x36453
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3490d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x3648c
movq %rsi, 0x48(%rdx)
movq %rsi, (%rcx,%rax,8)
leaq 0xe8(%rdi), %rax
cmpq $0x0, 0xe0(%rdi)
je 0x364b3
movq (%rax), %rcx
testq %rcx, %rcx
je 0x364c0
movq %rcx, 0x30(%rsi)
addq $0x38, %rcx
jmp 0x364bd
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_O3/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 0x5e067(%rip), %rsi     # 0x946c0
movq %r14, %rdi
callq 0x3622f
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x36682
movq (%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x36678
callq *%rax
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x38(%rbx)
movl %r15d, 0x110(%rbx)
leaq 0x7e5(%rip), %rax       # 0x36e75
movq %rax, 0xc0(%rbx)
leaq -0x1ead(%rip), %rax     # 0x347f1
movq %rax, 0xc8(%rbx)
movl $0x20, 0xe4(%rbx)
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x33d86
movq %rax, 0xd8(%rbx)
testq %rax, %rax
je 0x36756
movl 0xe4(%rbx), %ecx
shll $0x3, %ecx
testl %ecx, %ecx
je 0x36708
addq %rax, %rcx
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jae 0x36708
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jae 0x36708
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jae 0x36708
movb $0x0, (%rax)
incq %rax
cmpq %rcx, %rax
jb 0x366dc
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 0x7af(%rip), %r14       # 0x36eef
movq %r14, %rsi
callq *0x70(%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq *0x78(%rax)
xorl %eax, %eax
jmp 0x36763
movq %r14, %rdi
callq 0x2e588
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./lib/unqlite/unqlite.c
// Function: 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 0x367b3
movl $0xfffffff3, %eax       # imm = 0xFFFFFFF3
cmpl $0x1, %esi
jne 0x367fe
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
cmpl $0x0, 0xe0(%rdi)
jne 0x367fe
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x367df
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x367eb
movl (%rdx), %ecx
cmpq $0x28, %rcx
ja 0x367c9
movq %rcx, %rax
addq 0x10(%rdx), %rax
addl $0x8, %ecx
movl %ecx, (%rdx)
jmp 0x367d5
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc8, %ecx
jmp 0x367f3
movq 0x8(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq (%rax), %rax
movl $0xc0, %ecx
testq %rax, %rax
je 0x367fc
movq %rax, (%rdi,%rcx)
xorl %eax, %eax
popq %rbp
retq