LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_create_collation_v2
SQLITE_STDCALL sqlite3_create_collation_v2(
  sqlite3* db, 
  const char *zName, 
  int enc, 
  void* pCtx,
  int(*xCompare)(void*,int,const void*,int,const void*),
  void(*xDel)(void*)
){
  int rc;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  assert( !db->mallocFailed );
  rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r13
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1a4b7
movq %r9, %r15
movq %r8, %r12
movq %rcx, -0x30(%rbp)
callq *0x78efb(%rip)          # 0x933a8
movq -0x30(%rbp), %rcx
movq %r12, %r8
movq %r15, %r9
movzbl %r14b, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1a504
cmpb $0x0, 0x51(%rbx)
je 0x1a4dc
movq %rbx, %rdi
callq 0x28aa8
movl $0x7, %r14d
jmp 0x1a4e3
movl %eax, %r14d
andl 0x48(%rbx), %r14d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a4f2
callq *0x78ec6(%rip)          # 0x933b8
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_collation_needed
SQLITE_STDCALL sqlite3_collation_needed(
  sqlite3 *db, 
  void *pCollNeededArg, 
  void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->xCollNeeded = xCollNeeded;
  db->xCollNeeded16 = 0;
  db->pCollNeededArg = pCollNeededArg;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1a78d
callq *0x78c1b(%rip)          # 0x933a8
movq %r15, 0x128(%rbx)
movq $0x0, 0x130(%rbx)
movq %r14, 0x138(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a7b5
callq *0x78c03(%rip)          # 0x933b8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_collation_needed16
SQLITE_STDCALL sqlite3_collation_needed16(
  sqlite3 *db, 
  void *pCollNeededArg, 
  void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->xCollNeeded = 0;
  db->xCollNeeded16 = xCollNeeded16;
  db->pCollNeededArg = pCollNeededArg;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1a7e4
callq *0x78bc4(%rip)          # 0x933a8
movq $0x0, 0x128(%rbx)
movq %r15, 0x130(%rbx)
movq %r14, 0x138(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a80c
callq *0x78bac(%rip)          # 0x933b8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3Init
SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){
  int i, rc;
  int commit_internal = !(db->flags&SQLITE_InternChanges);
  
  assert( sqlite3_mutex_held(db->mutex) );
  assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
  assert( db->init.busy==0 );
  rc = SQLITE_OK;
  db->init.busy = 1;
  ENC(db) = SCHEMA_ENC(db);
  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
    if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
    rc = sqlite3InitOne(db, i, pzErrMsg);
    if( rc ){
      sqlite3ResetOneSchema(db, i);
    }
  }

  /* Once all the other databases have been initialized, load the schema
  ** for the TEMP database. This is loaded last, as the TEMP database
  ** schema may contain references to objects in other databases.
  */
#ifndef SQLITE_OMIT_TEMPDB
  assert( db->nDb>1 );
  if( rc==SQLITE_OK && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
    rc = sqlite3InitOne(db, 1, pzErrMsg);
    if( rc ){
      sqlite3ResetOneSchema(db, 1);
    }
  }
#endif

  db->init.busy = 0;
  if( rc==SQLITE_OK && commit_internal ){
    sqlite3CommitInternalChanges(db);
  }

  return rc; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
movl %eax, -0x2c(%rbp)
movb $0x1, 0xa1(%rdi)
movq 0x20(%rdi), %rax
movq 0x18(%rax), %rax
movb 0x71(%rax), %al
movb %al, 0x4e(%rdi)
movl $0x18, %r14d
xorl %r12d, %r12d
movslq 0x28(%rbx), %rcx
movq 0x20(%rbx), %rax
cmpq %rcx, %r12
jge 0x1ab71
movq (%rax,%r14), %rax
cmpq $0x1, %r12
sete %cl
orb 0x72(%rax), %cl
xorl %r15d, %r15d
testb $0x1, %cl
jne 0x1ab63
movq %rbx, %rdi
movl %r12d, %esi
movq -0x38(%rbp), %rdx
callq 0x77d8b
testl %eax, %eax
je 0x1ab63
movl %eax, %r13d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x330ff
movl %r13d, %r15d
incq %r12
addq $0x20, %r14
testl %r15d, %r15d
je 0x1ab1c
jmp 0x1aba6
movq 0x38(%rax), %rax
xorl %r15d, %r15d
testb $0x1, 0x72(%rax)
jne 0x1aba6
movq %rbx, %rdi
movl $0x1, %esi
movq -0x38(%rbp), %rdx
callq 0x77d8b
testl %eax, %eax
je 0x1aba6
movl %eax, %r14d
movq 0x20(%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x3761f
movl %r14d, %r15d
movl -0x2c(%rbp), %eax
andl $0x2, %eax
movb $0x0, 0xa1(%rbx)
orl %r15d, %eax
jne 0x1abbc
andb $-0x3, 0x2c(%rbx)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3FindTable
SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
  Table *p = 0;
  int i;

  /* All mutexes are required for schema access.  Make sure we hold them. */
  assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
#if SQLITE_USER_AUTHENTICATION
  /* Only the admin user is allowed to know that the sqlite_user table
  ** exists */
  if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
    return 0;
  }
#endif
  for(i=OMIT_TEMPDB; i<db->nDb; i++){
    int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */
    if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
    assert( sqlite3SchemaMutexHeld(db, j, 0) );
    p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
    if( p ) break;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movl 0x28(%rdi), %eax
xorl %r14d, %r14d
testl %eax, %eax
jle 0x1ac77
movq %rdx, %rbx
movq %rdi, %r15
decl %eax
movl %eax, -0x2c(%rbp)
xorl %r13d, %r13d
xorl %eax, %eax
cmpl $0x2, %r14d
setb %al
xorl %r14d, %eax
movl %eax, %r12d
testq %rbx, %rbx
je 0x1ac32
movq 0x20(%r15), %rax
movq %r12, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %rbx, %rdi
callq 0xa3f0
testl %eax, %eax
je 0x1ac32
xorl %eax, %eax
jmp 0x1ac64
movq 0x20(%r15), %rax
shlq $0x5, %r12
movq 0x18(%rax,%r12), %rdi
addq $0x8, %rdi
movq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x3d198
testq %rax, %rax
je 0x1ac5b
movq 0x10(%rax), %r13
jmp 0x1ac5e
xorl %r13d, %r13d
testq %r13, %r13
setne %al
testb %al, %al
jne 0x1ac7a
leal 0x1(%r14), %eax
cmpl %r14d, -0x2c(%rbp)
movl %eax, %r14d
jne 0x1abff
jmp 0x1ac7a
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_extended_result_codes
SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3 *db, int onoff){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->errMask = onoff ? 0xffffffff : 0xff;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1ad3d
callq *0x7866b(%rip)          # 0x933a8
xorl %eax, %eax
negl %r14d
sbbl %eax, %eax
orl $0xff, %eax
movl %eax, 0x48(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1ad5b
callq *0x7865d(%rip)          # 0x933b8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_file_control
SQLITE_STDCALL sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
  int rc = SQLITE_ERROR;
  Btree *pBtree;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  pBtree = sqlite3DbNameToBtree(db, zDbName);
  if( pBtree ){
    Pager *pPager;
    sqlite3_file *fd;
    sqlite3BtreeEnter(pBtree);
    pPager = sqlite3BtreePager(pBtree);
    assert( pPager!=0 );
    fd = sqlite3PagerFile(pPager);
    assert( fd!=0 );
    if( op==SQLITE_FCNTL_FILE_POINTER ){
      *(sqlite3_file**)pArg = fd;
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_VFS_POINTER ){
      *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager);
      rc = SQLITE_OK;
    }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){
      *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
      rc = SQLITE_OK;
    }else if( fd->pMethods ){
      rc = sqlite3OsFileControl(fd, op, pArg);
    }else{
      rc = SQLITE_NOTFOUND;
    }
    sqlite3BtreeLeave(pBtree);
  }
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1ad88
callq *0x78620(%rip)          # 0x933a8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ae4b
testq %rax, %rax
je 0x1add6
movq %rax, %r14
cmpb $0x0, 0x11(%rax)
je 0x1adb4
incl 0x14(%r14)
cmpb $0x0, 0x12(%r14)
jne 0x1adb4
movq %r14, %rdi
callq 0x25420
movq 0x8(%r14), %rax
movq (%rax), %rax
cmpl $0x1c, %r12d
je 0x1adde
cmpl $0x1b, %r12d
je 0x1adf4
movq 0x48(%rax), %rdi
cmpl $0x7, %r12d
jne 0x1ae2d
movq %rdi, (%r15)
jmp 0x1adfa
movl $0x1, %r15d
jmp 0x1ae12
movq 0x118(%rax), %rcx
leaq 0x10(%rcx), %rdx
addq $0x50, %rax
testq %rcx, %rcx
cmovneq %rdx, %rax
movq (%rax), %rax
movq %rax, (%r15)
xorl %r15d, %r15d
cmpb $0x0, 0x11(%r14)
je 0x1ae12
decl 0x14(%r14)
jne 0x1ae12
movq %r14, %rdi
callq 0x254a6
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1ae21
callq *0x78597(%rip)          # 0x933b8
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rdi), %rax
testq %rax, %rax
je 0x1ae43
movl %r12d, %esi
movq %r15, %rdx
callq *0x50(%rax)
movl %eax, %r15d
jmp 0x1adfd
movl $0xc, %r15d
jmp 0x1adfd
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeSetPageSize
SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){
  int rc = SQLITE_OK;
  BtShared *pBt = p->pBt;
  assert( nReserve>=-1 && nReserve<=255 );
  sqlite3BtreeEnter(p);
#if SQLITE_HAS_CODEC
  if( nReserve>pBt->optimalReserve ) pBt->optimalReserve = (u8)nReserve;
#endif
  if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
    sqlite3BtreeLeave(p);
    return SQLITE_READONLY;
  }
  if( nReserve<0 ){
    nReserve = pBt->pageSize - pBt->usableSize;
  }
  assert( nReserve>=0 && nReserve<=255 );
  if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
        ((pageSize-1)&pageSize)==0 ){
    assert( (pageSize & 7)==0 );
    assert( !pBt->pCursor );
    pBt->pageSize = (u32)pageSize;
    freeTempSpace(pBt);
  }
  rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
  pBt->usableSize = pBt->pageSize - (u16)nReserve;
  if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED;
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x8(%rdi), %r13
cmpb $0x0, 0x11(%rdi)
je 0x1b783
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x1b783
movq %rbx, %rdi
callq 0x25420
testb $0x2, 0x26(%r13)
jne 0x1b81a
testl %r15d, %r15d
jns 0x1b79b
movl 0x30(%r13), %r15d
subl 0x34(%r13), %r15d
leal -0x200(%r12), %eax
cmpl $0xfe00, %eax           # imm = 0xFE00
ja 0x1b7e2
leal 0x1ffff(%r12), %eax
testl %r12d, %eax
jne 0x1b7e2
movl %r12d, 0x30(%r13)
movq 0x80(%r13), %rdi
testq %rdi, %rdi
je 0x1b7e2
addq $-0x4, %rdi
movq %rdi, 0x80(%r13)
callq 0x21d0f
movq $0x0, 0x80(%r13)
movq (%r13), %rdi
leaq 0x30(%r13), %rsi
movl %r15d, %edx
callq 0x1f381
movl %eax, %r12d
movl 0x30(%r13), %eax
movzwl %r15w, %ecx
subl %ecx, %eax
movl %eax, 0x34(%r13)
testl %r14d, %r14d
je 0x1b80d
orb $0x2, 0x26(%r13)
cmpb $0x0, 0x11(%rbx)
je 0x1b83b
decl 0x14(%rbx)
jne 0x1b83b
jmp 0x1b82b
cmpb $0x0, 0x11(%rbx)
je 0x1b835
decl 0x14(%rbx)
movl $0x8, %r12d
jne 0x1b83b
movq %rbx, %rdi
callq 0x254a6
jmp 0x1b83b
movl $0x8, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ScratchMalloc
SQLITE_PRIVATE void *sqlite3ScratchMalloc(int n){
  void *p;
  assert( n>0 );

  sqlite3_mutex_enter(mem0.mutex);
  sqlite3StatusHighwater(SQLITE_STATUS_SCRATCH_SIZE, n);
  if( mem0.nScratchFree && sqlite3GlobalConfig.szScratch>=n ){
    p = mem0.pScratchFree;
    mem0.pScratchFree = mem0.pScratchFree->pNext;
    mem0.nScratchFree--;
    sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1);
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    sqlite3_mutex_leave(mem0.mutex);
    p = sqlite3Malloc(n);
    if( sqlite3GlobalConfig.bMemstat && p ){
      sqlite3_mutex_enter(mem0.mutex);
      sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p));
      sqlite3_mutex_leave(mem0.mutex);
    }
    sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
  }
  assert( sqlite3_mutex_notheld(mem0.mutex) );


#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
  /* EVIDENCE-OF: R-12970-05880 SQLite will not use more than one scratch
  ** buffers per thread.
  **
  ** This can only be checked in single-threaded mode.
  */
  assert( scratchAllocOut==0 );
  if( p ) scratchAllocOut++;
#endif

  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
movq 0x797ea(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0x1b869
callq *0x77b3f(%rip)          # 0x933a8
movslq %r14d, %rbx
cmpq %rbx, 0x797bd(%rip)     # 0x95030
jge 0x1b87c
movq %rbx, 0x797b4(%rip)     # 0x95030
movl 0x797e6(%rip), %eax     # 0x95068
testl %eax, %eax
je 0x1b8cc
cmpl %r14d, 0x77bdb(%rip)    # 0x93468
jl 0x1b8cc
movq 0x797ca(%rip), %rbx     # 0x95060
movq (%rbx), %rcx
movq %rcx, 0x797c0(%rip)     # 0x95060
decl %eax
movl %eax, 0x797c0(%rip)     # 0x95068
movq 0x79709(%rip), %rcx     # 0x94fb8
leaq 0x1(%rcx), %rax
movq %rax, 0x796fe(%rip)     # 0x94fb8
cmpq 0x79747(%rip), %rcx     # 0x95008
jl 0x1b93b
movq %rax, 0x7973e(%rip)     # 0x95008
jmp 0x1b93b
movq 0x79775(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0x1b8de
callq *0x77ada(%rip)          # 0x933b8
movq %rbx, %rdi
callq 0xbf9b
movq %rax, %rbx
cmpl $0x0, 0x77a30(%rip)     # 0x93320
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1b94d
movq 0x79741(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0x1b912
callq *0x77a96(%rip)          # 0x933a8
movq %rbx, %rdi
callq *0x77a45(%rip)          # 0x93360
cltq
addq 0x7969c(%rip), %rax     # 0x94fc0
movq %rax, 0x79695(%rip)     # 0x94fc0
cmpq 0x796de(%rip), %rax     # 0x95010
jle 0x1b93b
movq %rax, 0x796d5(%rip)     # 0x95010
movq 0x79706(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0x1b94d
callq *0x77a6b(%rip)          # 0x933b8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ScratchFree
SQLITE_PRIVATE void sqlite3ScratchFree(void *p){
  if( p ){

#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
    /* Verify that no more than two scratch allocation per thread
    ** is outstanding at one time.  (This is only checked in the
    ** single-threaded case since checking in the multi-threaded case
    ** would be much more complicated.) */
    assert( scratchAllocOut>=1 && scratchAllocOut<=2 );
    scratchAllocOut--;
#endif

    if( SQLITE_WITHIN(p, sqlite3GlobalConfig.pScratch, mem0.pScratchEnd) ){
      /* Release memory from the SQLITE_CONFIG_SCRATCH allocation */
      ScratchFreeslot *pSlot;
      pSlot = (ScratchFreeslot*)p;
      sqlite3_mutex_enter(mem0.mutex);
      pSlot->pNext = mem0.pScratchFree;
      mem0.pScratchFree = pSlot;
      mem0.nScratchFree++;
      assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
      sqlite3StatusDown(SQLITE_STATUS_SCRATCH_USED, 1);
      sqlite3_mutex_leave(mem0.mutex);
    }else{
      /* Release memory back to the heap */
      assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
      assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_SCRATCH) );
      sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
      if( sqlite3GlobalConfig.bMemstat ){
        int iSize = sqlite3MallocSize(p);
        sqlite3_mutex_enter(mem0.mutex);
        sqlite3StatusDown(SQLITE_STATUS_SCRATCH_OVERFLOW, iSize);
        sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, iSize);
        sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
        sqlite3GlobalConfig.m.xFree(p);
        sqlite3_mutex_leave(mem0.mutex);
      }else{
        sqlite3GlobalConfig.m.xFree(p);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1ba09
movq %rdi, %rbx
cmpq %rdi, 0x77af1(%rip)     # 0x93460
ja 0x1b9ac
cmpq %rbx, 0x796e0(%rip)     # 0x95058
jbe 0x1b9ac
movq 0x796c7(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0x1b98c
callq *0x77a1c(%rip)          # 0x933a8
movq 0x796cd(%rip), %rax     # 0x95060
movq %rax, (%rbx)
movq %rbx, 0x796c3(%rip)     # 0x95060
incl 0x796c5(%rip)           # 0x95068
decq 0x7960e(%rip)           # 0x94fb8
jmp 0x1b9f4
cmpl $0x0, 0x7796d(%rip)     # 0x93320
je 0x1ba0e
movq %rbx, %rdi
callq *0x779a2(%rip)          # 0x93360
movl %eax, %r14d
movq 0x79680(%rip), %rdi     # 0x95048
testq %rdi, %rdi
je 0x1b9d3
callq *0x779d5(%rip)          # 0x933a8
movslq %r14d, %rax
subq %rax, 0x795e3(%rip)     # 0x94fc0
subq %rax, 0x795bc(%rip)     # 0x94fa0
decq 0x795fd(%rip)           # 0x94fe8
movq %rbx, %rdi
callq *0x7795c(%rip)          # 0x93350
movq 0x7964d(%rip), %rbx     # 0x95048
testq %rbx, %rbx
je 0x1ba09
leaq 0x779b1(%rip), %rax     # 0x933b8
jmp 0x1ba15
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7793b(%rip), %rax     # 0x93350
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_uri_parameter
SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter(const char *zFilename, const char *zParam){
  if( zFilename==0 || zParam==0 ) return 0;
  zFilename += sqlite3Strlen30(zFilename) + 1;
  while( zFilename[0] ){
    int x = strcmp(zFilename, zParam);
    zFilename += sqlite3Strlen30(zFilename) + 1;
    if( x==0 ) return zFilename;
    zFilename += sqlite3Strlen30(zFilename) + 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x1ba3e
xorl %r14d, %r14d
jmp 0x1ba9e
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
leaq (%r14,%rax), %r15
incq %r15
cmpb $0x0, (%r15)
je 0x1ba39
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa2b0
movl %eax, %r12d
movq %r15, %rdi
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
addq %rax, %r15
incq %r15
testl %r12d, %r12d
je 0x1ba96
movq %r15, %rdi
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
addq %rax, %r15
incq %r15
jmp 0x1ba99
movq %r15, %r14
testl %r12d, %r12d
jne 0x1ba55
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_uri_int64
SQLITE_STDCALL sqlite3_uri_int64(
  const char *zFilename,    /* Filename as passed to xOpen */
  const char *zParam,       /* URI parameter sought */
  sqlite3_int64 bDflt       /* return if parameter is missing */
){
  const char *z = sqlite3_uri_parameter(zFilename, zParam);
  sqlite3_int64 v;
  if( z && sqlite3DecOrHexToI64(z, &v)==SQLITE_OK ){
    bDflt = v;
  }
  return bDflt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0xa300
testq %rax, %rax
je 0x1bb0b
leaq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x1bb15
testl %eax, %eax
jne 0x1bb0b
movq -0x10(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_db_filename
SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName){
  Btree *pBt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  pBt = sqlite3DbNameToBtree(db, zDbName);
  return pBt ? sqlite3BtreeGetFilename(pBt) : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1ae4b
testq %rax, %rax
je 0x1bc04
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0x13(%rax)
je 0x1bc08
leaq 0x6448f(%rip), %rax     # 0x80091
jmp 0x1bc0f
xorl %eax, %eax
jmp 0x1bc0f
movq 0xd0(%rax), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: enlargeAndAppend
static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
  N = sqlite3StrAccumEnlarge(p, N);
  if( N>0 ){
    memcpy(&p->zText[p->nChar], z, N);
    p->nChar += N;
  }
  assert( (p->zText==0 || p->zText==p->zBase)==(p->bMalloced==0) );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0x1bea2
testl %eax, %eax
jle 0x1be97
movl %eax, %r15d
movl 0x18(%rbx), %edi
addq 0x10(%rbx), %rdi
movl %eax, %edx
movq %r14, %rsi
callq 0xa310
addl %r15d, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3DbRealloc
SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
  void *pNew = 0;
  assert( db!=0 );
  assert( sqlite3_mutex_held(db->mutex) );
  if( db->mallocFailed==0 ){
    if( p==0 ){
      return sqlite3DbMallocRaw(db, n);
    }
    if( isLookaside(db, p) ){
      if( n<=db->lookaside.sz ){
        return p;
      }
      pNew = sqlite3DbMallocRaw(db, n);
      if( pNew ){
        memcpy(pNew, p, db->lookaside.sz);
        sqlite3DbFree(db, p);
      }
    }else{
      assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
      pNew = sqlite3_realloc64(p, n);
      if( !pNew ){
        db->mallocFailed = 1;
      }
      sqlite3MemdebugSetType(pNew,
            (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
    }
  }
  return pNew;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x51(%rdi)
je 0x1c01d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1c08d
cmpq %rbx, 0x170(%r14)
ja 0x1c080
cmpq %rbx, 0x178(%r14)
jbe 0x1c080
movzwl 0x150(%r14), %eax
cmpq %r15, %rax
jae 0x1c00f
movq %r14, %rdi
movq %r15, %rsi
callq 0x144ee
testq %rax, %rax
je 0x1c00d
movq %rax, %r15
movzwl 0x150(%r14), %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa310
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb6df
movq %r15, %rbx
jmp 0x1c00f
callq 0xa080
testl %eax, %eax
je 0x1c0a2
xorl %ebx, %ebx
jmp 0x1c0b0
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x144ee
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc1a4
movq %rax, %rbx
testq %rbx, %rbx
jne 0x1c00f
movb $0x1, 0x51(%r14)
jmp 0x1c00d
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: unixUnlock
static int unixUnlock(sqlite3_file *id, int eFileLock){
#if SQLITE_MAX_MMAP_SIZE>0
  assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 );
#endif
  return posixUnlock(id, eFileLock, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movzbl 0x1c(%rdi), %eax
xorl %r15d, %r15d
cmpl %esi, %eax
jle 0x1c97f
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x76aef(%rip)     # 0x93324
je 0x1c844
movl $0xb, %edi
callq *0x76b56(%rip)          # 0x93398
jmp 0x1c846
xorl %eax, %eax
testq %rax, %rax
je 0x1c854
movq %rax, %rdi
callq *0x76b54(%rip)          # 0x933a8
leaq 0x1c(%r14), %r12
movq 0x10(%r14), %r13
cmpb $0x2, 0x1c(%r14)
jb 0x1c8f0
cmpl $0x1, %ebx
jne 0x1c8af
leaq -0x48(%rbp), %rsi
movl $0x0, (%rsi)
movslq 0x76ef3(%rip), %rax     # 0x93770
addq $0x2, %rax
movq %rax, 0x8(%rsi)
movq $0x1fe, 0x10(%rsi)      # imm = 0x1FE
movq %r14, %rdi
callq 0x1de07
testl %eax, %eax
je 0x1c8af
callq 0xa0b0
movl (%rax), %eax
movl %eax, 0x20(%r14)
movl $0x90a, %r15d           # imm = 0x90A
jmp 0x1c950
leaq -0x48(%rbp), %rsi
movl $0x2, (%rsi)
movslq 0x76eb0(%rip), %rax     # 0x93770
movq %rax, 0x8(%rsi)
movq $0x2, 0x10(%rsi)
movq %r14, %rdi
callq 0x1de07
testl %eax, %eax
je 0x1c8eb
callq 0xa0b0
movl (%rax), %eax
movl %eax, 0x20(%r14)
movl $0x80a, %r15d           # imm = 0x80A
jmp 0x1c950
movb $0x1, 0x14(%r13)
xorl %r15d, %r15d
testl %ebx, %ebx
jne 0x1c950
xorl %r15d, %r15d
decl 0x10(%r13)
jne 0x1c942
leaq -0x48(%rbp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movq %r14, %rdi
callq 0x1de07
testl %eax, %eax
je 0x1c938
callq 0xa0b0
movl (%rax), %eax
movl %eax, 0x20(%r14)
movb $0x0, 0x14(%r13)
movl $0x80a, %r15d           # imm = 0x80A
movq %r12, %rax
jmp 0x1c93f
leaq 0x14(%r13), %rax
xorl %r15d, %r15d
movb $0x0, (%rax)
decl 0x28(%r13)
jne 0x1c950
movq %r14, %rdi
callq 0x1dcbf
cmpl $0x0, 0x769cd(%rip)     # 0x93324
je 0x1c966
movl $0xb, %edi
callq *0x76a34(%rip)          # 0x93398
jmp 0x1c968
xorl %eax, %eax
testq %rax, %rax
je 0x1c976
movq %rax, %rdi
callq *0x76a42(%rip)          # 0x933b8
testl %r15d, %r15d
jne 0x1c97f
movb %bl, (%r12)
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: unixShmBarrier
static void unixShmBarrier(
  sqlite3_file *fd                /* Database file holding the shared memory */
){
  UNUSED_PARAMETER(fd);
  sqlite3MemoryBarrier();         /* compiler-defined memory barrier */
  unixEnterMutex();               /* Also mutex, for redundancy */
  unixLeaveMutex();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
mfence
cmpl $0x0, 0x75bcf(%rip)     # 0x93324
je 0x1d764
movl $0xb, %edi
callq *0x75c36(%rip)          # 0x93398
jmp 0x1d766
xorl %eax, %eax
testq %rax, %rax
je 0x1d774
movq %rax, %rdi
callq *0x75c34(%rip)          # 0x933a8
cmpl $0x0, 0x75ba9(%rip)     # 0x93324
je 0x1d78a
movl $0xb, %edi
callq *0x75c10(%rip)          # 0x93398
jmp 0x1d78c
xorl %eax, %eax
testq %rax, %rax
je 0x1d79b
movq %rax, %rdi
popq %rbp
jmpq *0x75c1d(%rip)          # 0x933b8
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: verifyDbFile
static void verifyDbFile(unixFile *pFile){
  struct stat buf;
  int rc;
  rc = osFstat(pFile->h, &buf);
  if( rc!=0 ){
    sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink==0 && (pFile->ctrlFlags & UNIXFILE_DELETE)==0 ){
    sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink>1 ){
    sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
    return;
  }
  if( fileHasMoved(pFile) ){
    sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
movl 0x18(%rdi), %edi
leaq -0x98(%rbp), %rsi
callq *0x75eb6(%rip)          # 0x93800
testl %eax, %eax
je 0x1d96f
movq 0x38(%rbx), %rdx
leaq 0x5f8b7(%rip), %rsi     # 0x7d210
movl $0x1c, %edi
xorl %eax, %eax
callq 0xa4b0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %rbp
retq
movq -0x88(%rbp), %rax
testq %rax, %rax
jne 0x1d98e
testb $0x20, 0x1e(%rbx)
jne 0x1d98e
movq 0x38(%rbx), %rdx
leaq 0x5f89c(%rip), %rsi     # 0x7d228
jmp 0x1d959
cmpq $0x2, %rax
jb 0x1d9a1
movq 0x38(%rbx), %rdx
leaq 0x5f8a6(%rip), %rsi     # 0x7d245
jmp 0x1d959
cmpq $0x0, 0x10(%rbx)
je 0x1d965
movq 0x38(%rbx), %rdi
leaq -0x128(%rbp), %rsi
callq *0x75e2f(%rip)          # 0x937e8
testl %eax, %eax
jne 0x1d9ce
movq -0x120(%rbp), %rax
movq 0x10(%rbx), %rcx
cmpq 0x8(%rcx), %rax
je 0x1d965
movq 0x38(%rbx), %rdx
leaq 0x5f887(%rip), %rsi     # 0x7d260
jmp 0x1d959
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: unixFileLock
static int unixFileLock(unixFile *pFile, struct flock *pLock){
  int rc;
  unixInodeInfo *pInode = pFile->pInode;
  assert( unixMutexHeld() );
  assert( pInode!=0 );
  if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
    if( pInode->bProcessLock==0 ){
      struct flock lock;
      assert( pInode->nLock==0 );
      lock.l_whence = SEEK_SET;
      lock.l_start = SHARED_FIRST;
      lock.l_len = SHARED_SIZE;
      lock.l_type = F_WRLCK;
      rc = osFcntl(pFile->h, F_SETLK, &lock);
      if( rc<0 ) return rc;
      pInode->bProcessLock = 1;
      pInode->nLock++;
    }else{
      rc = 0;
    }
  }else{
    rc = osFcntl(pFile->h, F_SETLK, pLock);
  }
  return rc;
}

// Assembly:
movzwl 0x1e(%rdi), %eax
andl $0x3, %eax
cmpw $0x1, %ax
jne 0x1de6c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rbx
xorl %eax, %eax
cmpb $0x0, 0x15(%rbx)
jne 0x1de65
movslq 0x75940(%rip), %rax     # 0x93770
addq $0x2, %rax
leaq -0x28(%rbp), %rdx
movq %rax, 0x8(%rdx)
movq $0x1fe, 0x10(%rdx)      # imm = 0x1FE
movl $0x1, (%rdx)
movl 0x18(%rdi), %edi
movl $0x6, %esi
xorl %eax, %eax
callq *0x759d6(%rip)          # 0x93830
testl %eax, %eax
js 0x1de65
movb $0x1, 0x15(%rbx)
incl 0x28(%rbx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rdx
movq 0x759ba(%rip), %rcx     # 0x93830
movl 0x18(%rdi), %edi
movl $0x6, %esi
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: unixShmPurge
static void unixShmPurge(unixFile *pFd){
  unixShmNode *p = pFd->pInode->pShmNode;
  assert( unixMutexHeld() );
  if( p && ALWAYS(p->nRef==0) ){
    int nShmPerMap = unixShmRegionPerMap();
    int i;
    assert( p->pInode==pFd->pInode );
    sqlite3_mutex_free(p->mutex);
    for(i=0; i<p->nRegion; i+=nShmPerMap){
      if( p->h>=0 ){
        osMunmap(p->apRegion[i], p->szRegion);
      }else{
        sqlite3_free(p->apRegion[i]);
      }
    }
    sqlite3_free(p->apRegion);
    if( p->h>=0 ){
      robust_close(pFd, p->h, __LINE__);
      p->h = -1;
    }
    p->pInode->pShmNode = 0;
    sqlite3_free(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x1e1d8
cmpl $0x0, 0x30(%rbx)
je 0x1e1e1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
callq *0x757f6(%rip)          # 0x939e0
movl %eax, %ecx
shrl $0xf, %ecx
cmpl $0x8000, %eax           # imm = 0x8000
movl $0x1, %r15d
cmovgel %ecx, %r15d
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e20d
callq *0x75193(%rip)          # 0x933a0
cmpw $0x0, 0x20(%rbx)
je 0x1e24d
movl %r15d, %r15d
xorl %r12d, %r12d
cmpl $0x0, 0x18(%rbx)
js 0x1e234
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
movslq 0x1c(%rbx), %rsi
callq *0x7577e(%rip)          # 0x939b0
jmp 0x1e241
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0xa620
addq %r15, %r12
movzwl 0x20(%rbx), %eax
cmpq %rax, %r12
jb 0x1e21a
movq 0x28(%rbx), %rdi
callq 0xa620
movl 0x18(%rbx), %esi
testl %esi, %esi
js 0x1e271
movq %r14, %rdi
movl $0x79e1, %edx           # imm = 0x79E1
callq 0x1dd0f
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
movq (%rbx), %rax
movq $0x0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa620
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VMPrintf
SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
  assert( db!=0 );
  sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
                      db->aLimit[SQLITE_LIMIT_LENGTH]);
  sqlite3VXPrintf(&acc, SQLITE_PRINTF_INTERNAL, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  if( acc.accError==STRACCUM_NOMEM ){
    db->mallocFailed = 1;
  }
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movl 0x68(%rdi), %eax
leaq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %r14
movq %rsi, 0x8(%r14)
movq %rsi, 0x10(%r14)
movq %rdi, (%r14)
movabsq $0x4600000000, %rsi     # imm = 0x4600000000
movq %rsi, 0x18(%r14)
movl %eax, 0x20(%r14)
movw $0x0, 0x24(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0xc3ef
movq %r14, %rdi
callq 0xda95
cmpb $0x1, 0x24(%r14)
jne 0x1e44e
movb $0x1, 0x51(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheSetPageSize
SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *pCache, int szPage){
  assert( pCache->nRefSum==0 && pCache->pDirty==0 );
  if( pCache->szPage ){
    sqlite3_pcache *pNew;
    pNew = sqlite3GlobalConfig.pcache2.xCreate(
                szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)),
                pCache->bPurgeable
    );
    if( pNew==0 ) return SQLITE_NOMEM;
    sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache));
    if( pCache->pCache ){
      sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
    }
    pCache->pCache = pNew;
    pCache->szPage = szPage;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x24(%rdi)
je 0x1f818
movl %esi, %ebx
movq %rdi, %r14
movl 0x28(%rdi), %esi
addl $0x48, %esi
movzbl 0x2c(%rdi), %edx
movl %ebx, %edi
callq *0x73c34(%rip)          # 0x933f0
movl $0x7, %r15d
testq %rax, %rax
je 0x1f81b
movq %rax, %r12
movq 0x73c27(%rip), %rcx     # 0x933f8
movslq 0x1c(%r14), %rsi
testq %rsi, %rsi
jns 0x1f7f7
shlq $0xa, %rsi
negq %rsi
movslq 0x24(%r14), %rax
movslq 0x28(%r14), %rdi
addq %rax, %rdi
movq %rsi, %rax
cqto
idivq %rdi
movq %rax, %rsi
movq %r12, %rdi
callq *%rcx
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x1f80b
callq *0x73c1d(%rip)          # 0x93428
movq %r12, 0x40(%r14)
movl %ebx, 0x24(%r14)
testq %r12, %r12
je 0x1f81b
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: subjournalPageIfRequired
static int subjournalPageIfRequired(PgHdr *pPg){
  if( subjRequiresPage(pPg) ){
    return subjournalPage(pPg);
  }else{
    return SQLITE_OK;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x20(%rdi), %rbx
movslq 0x80(%rbx), %rax
testq %rax, %rax
jle 0x1f880
movq %rdi, -0x30(%rbp)
movl 0x28(%rdi), %r15d
movq 0x78(%rbx), %r12
shlq $0x4, %rax
leaq (%rax,%rax,2), %r13
xorl %r14d, %r14d
cmpl %r15d, 0x18(%r12,%r14)
jb 0x1f877
movq 0x10(%r12,%r14), %rdi
movl %r15d, %esi
callq 0x20299
testl %eax, %eax
je 0x1f891
addq $0x30, %r14
cmpq %r14, %r13
jne 0x1f85f
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x9(%rbx), %cl
xorl %eax, %eax
cmpb $0x2, %cl
je 0x1f92b
movq 0x58(%rbx), %rdx
xorl %eax, %eax
cmpq $0x0, (%rdx)
jne 0x1f8d2
cmpb $0x4, %cl
je 0x1f8ba
cmpb $0x0, 0x19(%rbx)
je 0x1f94a
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movups %xmm0, 0x20(%rdx)
movups %xmm0, 0x10(%rdx)
leaq 0x71fc1(%rip), %rcx     # 0x91890
movq %rcx, (%rdx)
testl %eax, %eax
jne 0x1f92b
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %r15
movl 0x38(%rbx), %eax
movslq 0xbc(%rbx), %r12
addq $0x4, %r12
imulq %rax, %r12
movq 0x58(%rbx), %rdi
movl 0x28(%rcx), %eax
bswapl %eax
leaq -0x34(%rbp), %rsi
movl %eax, (%rsi)
movq (%rdi), %rax
movl $0x4, %edx
movq %r12, %rcx
callq *0x18(%rax)
testl %eax, %eax
jne 0x1f92b
movq 0x58(%rbx), %rdi
movl 0xbc(%rbx), %edx
addq $0x4, %r12
movq (%rdi), %rax
movq %r15, %rsi
movq %r12, %rcx
callq *0x18(%rax)
testl %eax, %eax
jne 0x1f882
incl 0x38(%rbx)
movq -0x30(%rbp), %rax
movl 0x28(%rax), %esi
movq %rbx, %rdi
callq 0x2032c
jmp 0x1f882
movq (%rbx), %rdi
xorl %esi, %esi
movl $0x201e, %ecx           # imm = 0x201E
xorl %r8d, %r8d
callq *0x28(%rdi)
jmp 0x1f8d2
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheMakeClean
SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){
  if( (p->flags & PGHDR_DIRTY) ){
    assert( (p->flags & PGHDR_CLEAN)==0 );
    pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);
    p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE);
    p->flags |= PGHDR_CLEAN;
    if( p->nRef==0 ){
      pcacheUnpin(p);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testb $0x2, 0x2c(%rdi)
je 0x20270
movq %rdi, %rbx
movl $0x1, %esi
callq 0x21c64
movl 0x2c(%rbx), %eax
andl $-0x10, %eax
incl %eax
movw %ax, 0x2c(%rbx)
cmpw $0x0, 0x2e(%rbx)
je 0x20277
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x30(%rbx), %rax
cmpb $0x0, 0x2c(%rax)
je 0x20270
movq 0x73188(%rip), %rcx     # 0x93410
movq 0x40(%rax), %rdi
movq (%rbx), %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcacheManageDirtyList
static void pcacheManageDirtyList(PgHdr *pPage, u8 addRemove){
  PCache *p = pPage->pCache;

  if( addRemove & PCACHE_DIRTYLIST_REMOVE ){
    assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
    assert( pPage->pDirtyPrev || pPage==p->pDirty );
  
    /* Update the PCache1.pSynced variable if necessary. */
    if( p->pSynced==pPage ){
      PgHdr *pSynced = pPage->pDirtyPrev;
      while( pSynced && (pSynced->flags&PGHDR_NEED_SYNC) ){
        pSynced = pSynced->pDirtyPrev;
      }
      p->pSynced = pSynced;
    }
  
    if( pPage->pDirtyNext ){
      pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev;
    }else{
      assert( pPage==p->pDirtyTail );
      p->pDirtyTail = pPage->pDirtyPrev;
    }
    if( pPage->pDirtyPrev ){
      pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext;
    }else{
      assert( pPage==p->pDirty );
      p->pDirty = pPage->pDirtyNext;
      if( p->pDirty==0 && p->bPurgeable ){
        assert( p->eCreate==1 );
        p->eCreate = 2;
      }
    }
    pPage->pDirtyNext = 0;
    pPage->pDirtyPrev = 0;
  }
  if( addRemove & PCACHE_DIRTYLIST_ADD ){
    assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage );
  
    pPage->pDirtyNext = p->pDirty;
    if( pPage->pDirtyNext ){
      assert( pPage->pDirtyNext->pDirtyPrev==0 );
      pPage->pDirtyNext->pDirtyPrev = pPage;
    }else{
      p->pDirtyTail = pPage;
      if( p->bPurgeable ){
        assert( p->eCreate==2 );
        p->eCreate = 1;
      }
    }
    p->pDirty = pPage;
    if( !p->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){
      p->pSynced = pPage;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rax
testb $0x1, %sil
je 0x21cd3
cmpq %rdi, 0x10(%rax)
jne 0x21c8e
movq %rdi, %rcx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
je 0x21c8a
testb $0x8, 0x2c(%rcx)
jne 0x21c7b
movq %rcx, 0x10(%rax)
leaq 0x38(%rdi), %rcx
movq 0x38(%rdi), %rdx
leaq 0x8(%rax), %r8
leaq 0x40(%rdx), %r9
testq %rdx, %rdx
cmoveq %r8, %r9
movq 0x40(%rdi), %r8
movq %r8, (%r9)
movq 0x40(%rdi), %r8
testq %r8, %r8
je 0x21cbb
movq %rdx, 0x38(%r8)
jmp 0x21ccd
movq %rdx, (%rax)
testq %rdx, %rdx
jne 0x21ccd
cmpb $0x0, 0x2c(%rax)
je 0x21ccd
movb $0x2, 0x2d(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
testb $0x2, %sil
je 0x21d0d
movq (%rax), %rcx
movq %rcx, 0x38(%rdi)
testq %rcx, %rcx
je 0x21ceb
movq %rdi, 0x40(%rcx)
jmp 0x21cf9
movq %rdi, 0x8(%rax)
cmpb $0x0, 0x2c(%rax)
je 0x21cf9
movb $0x1, 0x2d(%rax)
movq %rdi, (%rax)
cmpq $0x0, 0x10(%rax)
jne 0x21d0d
testb $0x8, 0x2c(%rdi)
jne 0x21d0d
movq %rdi, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: btreeParseCellPtrNoPayload
static void btreeParseCellPtrNoPayload(
  MemPage *pPage,         /* Page containing the cell */
  u8 *pCell,              /* Pointer to the cell text. */
  CellInfo *pInfo         /* Fill in this structure */
){
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->leaf==0 );
  assert( pPage->noPayload );
  assert( pPage->childPtrSize==4 );
#ifndef SQLITE_DEBUG
  UNUSED_PARAMETER(pPage);
#endif
  pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey);
  pInfo->nPayload = 0;
  pInfo->nLocal = 0;
  pInfo->pPayload = 0;
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq 0x4(%rsi), %rdi
movq %rdx, %rsi
callq 0x2244f
addb $0x4, %al
movzbl %al, %eax
movw %ax, 0x16(%rbx)
movl $0x0, 0x10(%rbx)
movw $0x0, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheTruncate
SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
  if( pCache->pCache ){
    PgHdr *p;
    PgHdr *pNext;
    for(p=pCache->pDirty; p; p=pNext){
      pNext = p->pDirtyNext;
      /* This routine never gets call with a positive pgno except right
      ** after sqlite3PcacheCleanAll().  So if there are dirty pages,
      ** it must be that pgno==0.
      */
      assert( p->pgno>0 );
      if( ALWAYS(p->pgno>pgno) ){
        assert( p->flags&PGHDR_DIRTY );
        sqlite3PcacheMakeClean(p);
      }
    }
    if( pgno==0 && pCache->nRefSum ){
      sqlite3_pcache_page *pPage1;
      pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0);
      if( ALWAYS(pPage1) ){  /* Page 1 is always available in cache, because
                             ** pCache->nRefSum>0 */
        memset(pPage1->pBuf, 0, pCache->szPage);
        pgno = 1;
      }
    }
    sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
  }
}

// Assembly:
cmpq $0x0, 0x40(%rdi)
je 0x227ac
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2278a
movq 0x38(%rdi), %r15
cmpl %r14d, 0x28(%rdi)
jbe 0x22782
callq 0x20244
movq %r15, %rdi
testq %r15, %r15
jne 0x22773
testl %r14d, %r14d
je 0x227ad
movq 0x70c8a(%rip), %rax     # 0x93420
movq 0x40(%rbx), %rdi
incl %r14d
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
retq
cmpl $0x0, 0x18(%rbx)
je 0x227e2
movq 0x40(%rbx), %rdi
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq *0x70c41(%rip)          # 0x93408
testq %rax, %rax
je 0x2278f
movq (%rax), %rdi
movslq 0x24(%rbx), %rdx
xorl %esi, %esi
callq 0xa210
movl $0x1, %r14d
jmp 0x2278f
xorl %r14d, %r14d
jmp 0x2278f
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheDrop
SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){
  assert( p->nRef==1 );
  if( p->flags&PGHDR_DIRTY ){
    pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);
  }
  p->pCache->nRefSum--;
  sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x2, 0x2c(%rdi)
je 0x24d84
movq %rbx, %rdi
movl $0x1, %esi
callq 0x21c64
movq 0x30(%rbx), %rax
decl 0x18(%rax)
movq 0x6e67e(%rip), %rcx     # 0x93410
movq 0x40(%rax), %rdi
movq (%rbx), %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PagerUnrefNotNull
SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){
  Pager *pPager;
  assert( pPg!=0 );
  pPager = pPg->pPager;
  if( pPg->flags & PGHDR_MMAP ){
    pagerReleaseMapPage(pPg);
  }else{
    sqlite3PcacheRelease(pPg);
  }
  pagerUnlockIfUnused(pPager);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rbx
testb $0x40, 0x2c(%rdi)
jne 0x25037
callq 0x2513c
jmp 0x25073
decl 0x98(%rbx)
movq 0xa8(%rbx), %rax
movq %rax, 0x18(%rdi)
movq %rdi, 0xa8(%rbx)
movq 0x48(%rbx), %rax
movl 0x28(%rdi), %ecx
decl %ecx
movslq 0xbc(%rbx), %rsi
imulq %rcx, %rsi
movq 0x8(%rdi), %rdx
movq (%rax), %rcx
movq %rax, %rdi
callq *0x90(%rcx)
cmpl $0x0, 0x98(%rbx)
jne 0x25089
movq 0x110(%rbx), %rax
cmpl $0x0, 0x18(%rax)
je 0x25090
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22a5d
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcacheFetchFinishWithInit
static SQLITE_NOINLINE PgHdr *pcacheFetchFinishWithInit(
  PCache *pCache,             /* Obtain the page from this cache */
  Pgno pgno,                  /* Page number obtained */
  sqlite3_pcache_page *pPage  /* Page obtained by prior PcacheFetch() call */
){
  PgHdr *pPgHdr;
  assert( pPage!=0 );
  pPgHdr = (PgHdr*)pPage->pExtra;
  assert( pPgHdr->pPage==0 );
  memset(pPgHdr, 0, sizeof(PgHdr));
  pPgHdr->pPage = pPage;
  pPgHdr->pData = pPage->pBuf;
  pPgHdr->pExtra = (void *)&pPgHdr[1];
  memset(pPgHdr->pExtra, 0, pCache->szExtra);
  pPgHdr->pCache = pCache;
  pPgHdr->pgno = pgno;
  pPgHdr->flags = PGHDR_CLEAN;
  return sqlite3PcacheFetchFinish(pCache,pgno,pPage);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq 0x8(%rdx), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movq $0x0, 0x40(%r12)
movq %rdx, (%r12)
movq (%rdx), %rax
movq %rax, 0x8(%r12)
leaq 0x48(%r12), %rdi
movq %rdi, 0x10(%r12)
movslq 0x28(%r15), %rdx
xorl %esi, %esi
callq 0xa210
movq %r15, 0x30(%r12)
movl %r14d, 0x28(%r12)
movw $0x1, 0x2c(%r12)
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2509e
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheRelease
SQLITE_NOINLINE sqlite3PcacheRelease(PgHdr *p){
  assert( p->nRef>0 );
  p->pCache->nRefSum--;
  if( (--p->nRef)==0 ){
    if( p->flags&PGHDR_CLEAN ){
      pcacheUnpin(p);
    }else if( p->pDirtyPrev!=0 ){
      /* Move the page to the head of the dirty list. */
      pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rax
decl 0x18(%rax)
decw 0x2e(%rdi)
je 0x2514f
popq %rbp
retq
testb $0x1, 0x2c(%rdi)
jne 0x25167
cmpq $0x0, 0x40(%rdi)
je 0x2514d
movl $0x3, %esi
popq %rbp
jmp 0x21c64
cmpb $0x0, 0x2c(%rax)
je 0x2514d
movq 0x6e29c(%rip), %rcx     # 0x93410
movq 0x40(%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
xorl %edx, %edx
popq %rbp
jmpq *%rcx