LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_vfs_unregister
SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  sqlite3_mutex_leave(mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x404c3e
testl %eax, %eax
jne 0x40505e
cmpl $0x0, 0x19b116(%rip)    # 0x5a0134
je 0x405030
movl $0x2, %edi
callq *0x19b185(%rip)         # 0x5a01b0
movq %rax, %r14
jmp 0x405033
xorl %r14d, %r14d
testq %r14, %r14
je 0x405054
movq %r14, %rdi
callq *0x19b17f(%rip)         # 0x5a01c0
movq %rbx, %rdi
callq 0x404fc5
movq %r14, %rdi
callq *0x19b17e(%rip)         # 0x5a01d0
jmp 0x40505c
movq %rbx, %rdi
callq 0x404fc5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_mutex_alloc
SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int id){
#ifndef SQLITE_OMIT_AUTOINIT
  if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0;
  if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0;
#endif
  assert( sqlite3GlobalConfig.mutex.xMutexAlloc );
  return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x1, %edi
jg 0x405077
callq 0x404c3e
testl %eax, %eax
jne 0x405085
cmpl $0x2, %ebx
jl 0x405089
callq 0x405092
testl %eax, %eax
je 0x405089
xorl %eax, %eax
popq %rbx
retq
movl %ebx, %edi
popq %rbx
jmpq *0x19b11e(%rip)         # 0x5a01b0
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3StrICmp
SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){
  unsigned char *a, *b;
  int c;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  for(;;){
    c = (int)UpperToLower[*a] - (int)UpperToLower[*b];
    if( c || *a==0 ) break;
    a++;
    b++;
  }
  return c;
}

// Assembly:
movzbl (%rdi), %r8d
leaq 0x144cac(%rip), %rax    # 0x54c3e0
movzbl (%rsi), %ecx
movb (%rcx,%rax), %dl
movb (%r8,%rax), %cl
testq %r8, %r8
je 0x40776a
cmpb %dl, %cl
jne 0x40776a
movl $0x1, %r8d
movzbl (%rdi,%r8), %r9d
movb (%r9,%rax), %cl
movzbl (%rsi,%r8), %edx
movb (%rdx,%rax), %dl
testq %r9, %r9
je 0x40776a
incq %r8
cmpb %dl, %cl
je 0x40774d
movzbl %dl, %edx
movzbl %cl, %eax
subl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ResetAllSchemasOfConnection
SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
  int i;
  sqlite3BtreeEnterAll(db);
  assert( db->nSchemaLock==0 );
  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){
      sqlite3SchemaClear(pDb->pSchema);
    }
  }
  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
  sqlite3VtabUnlockList(db);
  sqlite3BtreeLeaveAll(db);
  sqlite3CollapseDatabaseArray(db);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x69(%rdi)
jne 0x409d22
movq %rbx, %rdi
callq 0x4182c5
cmpl $0x0, 0x28(%rbx)
jle 0x409d53
movl $0x18, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x409d43
callq 0x4319bc
incq %r15
movslq 0x28(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x409d31
andb $-0xa, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x43c6d9
cmpb $0x0, 0x69(%rbx)
jne 0x409d6d
movq %rbx, %rdi
callq 0x41832a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x43c729
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3PagerSync
SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster){
  int rc = SQLITE_OK;
  void *pArg = (void*)zMaster;
  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
  if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
  if( rc==SQLITE_OK && !pPager->noSync ){
    assert( !MEMDB );
    rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
  }
  return rc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x40a043
movq %rsi, %rdx
movl $0x15, %esi
callq *0x50(%rax)
jmp 0x40a048
movl $0xc, %eax
xorl %ecx, %ecx
cmpl $0xc, %eax
cmovel %ecx, %eax
testl %eax, %eax
jne 0x40a05c
cmpb $0x0, 0xb(%rbx)
je 0x40a05e
xorl %eax, %eax
popq %rbx
retq
movzbl 0xe(%rbx), %esi
movl $0x0, %eax
testl %esi, %esi
je 0x40a05c
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: invokeProfileCallback
static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
  sqlite3_int64 iNow;
  sqlite3_int64 iElapse;
  assert( p->startTime>0 );
  assert( db->xProfile!=0 || (db->mTrace & SQLITE_TRACE_PROFILE)!=0 );
  assert( db->init.busy==0 );
  assert( p->zSql!=0 );
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  iElapse = (iNow - p->startTime)*1000000;
  if( db->xProfile ){
    db->xProfile(db->pProfileArg, p->zSql, iElapse);
  }
  if( db->mTrace & SQLITE_TRACE_PROFILE ){
    db->xTrace(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
  }
  p->startTime = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x4235a7
movq (%r15), %rax
subq 0xb0(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
movq %rdx, (%rsp)
movq 0xe8(%r14), %rax
testq %rax, %rax
je 0x40a9ce
movq 0xf0(%r14), %rdi
movq 0xe8(%rbx), %rsi
callq *%rax
testb $0x2, 0x68(%r14)
je 0x40a9ee
movq 0xe0(%r14), %rsi
movq %rsp, %rcx
movl $0x2, %edi
movq %rbx, %rdx
callq *0xd8(%r14)
movq $0x0, 0xb0(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VdbeMemExpandBlob
SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
  int nByte;
  assert( pMem->flags & MEM_Zero );
  assert( pMem->flags&MEM_Blob );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );

  /* Set nByte to the number of bytes required to store the expanded blob. */
  nByte = pMem->n + pMem->u.nZero;
  if( nByte<=0 ){
    nByte = 1;
  }
  if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
    return SQLITE_NOMEM_BKPT;
  }

  memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
  pMem->n += pMem->u.nZero;
  pMem->flags &= ~(MEM_Zero|MEM_Term);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %esi
addl 0xc(%rdi), %esi
cmpl $0x2, %esi
movl $0x1, %eax
cmovll %eax, %esi
movl $0x1, %edx
callq 0x425122
movl $0x7, %ebp
testl %eax, %eax
jne 0x40aca7
movslq 0xc(%rbx), %rdi
addq 0x10(%rbx), %rdi
movslq (%rbx), %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x4010b8
movl (%rbx), %eax
addl %eax, 0xc(%rbx)
andb $-0x43, 0x9(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VdbeRealValue
SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  if( pMem->flags & MEM_Real ){
    return pMem->u.r;
  }else if( pMem->flags & MEM_Int ){
    return (double)pMem->u.i;
  }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
    return memRealValue(pMem);
  }else{
    /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
    return (double)0;
  }
}

// Assembly:
movzwl 0x8(%rdi), %eax
testb $0x8, %al
jne 0x40ad17
testb $0x4, %al
jne 0x40ad1c
testb $0x12, %al
jne 0x425a05
xorps %xmm0, %xmm0
retq
movsd (%rdi), %xmm0
retq
cvtsi2sdq (%rdi), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_next_stmt
SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
  sqlite3_stmt *pNext;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(pDb) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(pDb->mutex);
  if( pStmt==0 ){
    pNext = (sqlite3_stmt*)pDb->pVdbe;
  }else{
    pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
  }
  sqlite3_mutex_leave(pDb->mutex);
  return pNext;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x40d30f
callq *0x192eb1(%rip)         # 0x5a01c0
leaq 0x8(%rbx), %rax
leaq 0x10(%r14), %rcx
testq %r14, %r14
cmoveq %rax, %rcx
movq (%rcx), %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40d330
callq *0x192ea0(%rip)         # 0x5a01d0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_expanded_sql
SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){
#ifdef SQLITE_OMIT_TRACE
  return 0;
#else
  char *z = 0;
  const char *zSql = sqlite3_sql(pStmt);
  if( zSql ){
    Vdbe *p = (Vdbe *)pStmt;
    sqlite3_mutex_enter(p->db->mutex);
    z = sqlite3VdbeExpandSql(p, zSql);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return z;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x40d3eb
movq 0xe8(%rbx), %r14
jmp 0x40d3ee
xorl %r14d, %r14d
testq %r14, %r14
je 0x40d427
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x40d405
callq *0x192dbb(%rip)         # 0x5a01c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40d435
movq %rax, %r14
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x40d42a
callq *0x192dab(%rip)         # 0x5a01d0
jmp 0x40d42a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: applyNumericAffinity
static void applyNumericAffinity(Mem *pRec, int bTryForInt){
  double rValue;
  i64 iValue;
  u8 enc = pRec->enc;
  assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str );
  if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return;
  if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){
    pRec->u.i = iValue;
    pRec->flags |= MEM_Int;
  }else{
    pRec->u.r = rValue;
    pRec->flags |= MEM_Real;
    if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
  }
  /* TEXT->NUMERIC is many->one.  Hence, it is important to invalidate the
  ** string representation after computing a numeric equivalent, because the
  ** string representation might not be the canonical representation for the
  ** numeric value.  Ticket [343634942dd54ab57b7024] 2018-01-31. */
  pRec->flags &= ~MEM_Str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movl 0xc(%rdi), %r14d
movzbl 0xa(%rdi), %r12d
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x425a36
testl %eax, %eax
je 0x40d961
movq %rsp, %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x425f82
testl %eax, %eax
je 0x40d952
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
orb $0x8, 0x8(%rbx)
testl %ebp, %ebp
je 0x40d95d
movq %rbx, %rdi
callq 0x42f31c
jmp 0x40d95d
movq (%rsp), %rax
movq %rax, (%rbx)
orb $0x4, 0x8(%rbx)
andb $-0x3, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ParserReset
SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
  sqlite3 *db = pParse->db;
  sqlite3DbFree(db, pParse->aLabel);
  sqlite3ExprListDelete(db, pParse->pConstExpr);
  if( db ){
    assert( db->lookaside.bDisable >= pParse->disableLookaside );
    db->lookaside.bDisable -= pParse->disableLookaside;
  }
  pParse->disableLookaside = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
je 0x40ea08
movq %r14, %rdi
callq 0x415dca
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x40ea19
movq %r14, %rdi
callq 0x439a79
testq %r14, %r14
je 0x40ea29
movzbl 0x24(%rbx), %eax
subl %eax, 0x160(%r14)
movb $0x0, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_errmsg
SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){
  const char *z;
  if( !db ){
    return sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mallocFailed ){
    z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }else{
    testcase( db->pErr==0 );
    z = (char*)sqlite3_value_text(db->pErr);
    assert( !db->mallocFailed );
    if( z==0 ){
      z = sqlite3ErrStr(db->errCode);
    }
  }
  sqlite3_mutex_leave(db->mutex);
  return z;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x40f781
movq %rdi, %rbx
callq 0x413dc2
testl %eax, %eax
je 0x40f78a
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40f772
callq *0x190a4e(%rip)         # 0x5a01c0
cmpb $0x0, 0x61(%rbx)
je 0x40f7b9
leaq 0x141b83(%rip), %r14    # 0x551302
jmp 0x40f7d2
leaq 0x141b7a(%rip), %r14    # 0x551302
jmp 0x40f7e1
leaq 0x141116(%rip), %rsi    # 0x5508a7
leaq 0x1454b8(%rip), %rdx    # 0x554c50
leaq 0x140f3f(%rip), %r8     # 0x5506de
movl $0x15, %edi
movl $0x25a2f, %ecx          # imm = 0x25A2F
xorl %eax, %eax
callq 0x40743a
leaq 0x14547e(%rip), %r14    # 0x554c35
jmp 0x40f7e1
movq 0x150(%rbx), %rdi
movl $0x1, %esi
callq 0x40ad95
movq %rax, %r14
testq %rax, %rax
je 0x40f7ec
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40f7e1
callq *0x1909ef(%rip)         # 0x5a01d0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x50(%rbx), %eax
cmpq $0x204, %rax            # imm = 0x204
je 0x40f813
cmpl $0x65, %eax
je 0x40f80a
cmpl $0x64, %eax
jne 0x40f81c
leaq 0x1454de(%rip), %r14    # 0x554ce6
jmp 0x40f7d2
leaq 0x1454eb(%rip), %r14    # 0x554cfc
jmp 0x40f7d2
leaq 0x1454b6(%rip), %r14    # 0x554cd0
jmp 0x40f7d2
movzbl %al, %eax
leaq 0x14549c(%rip), %r14    # 0x554cc2
cmpl $0x1c, %eax
ja 0x40f7d2
movl $0x1410004, %ecx        # imm = 0x1410004
btq %rax, %rcx
jb 0x40f7d2
leaq 0x18f033(%rip), %rcx    # 0x59e870
movq (%rcx,%rax,8), %r14
jmp 0x40f7d2
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_enable_load_extension
SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
  sqlite3_mutex_enter(db->mutex);
  if( onoff ){
    db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;
  }else{
    db->flags &= ~(SQLITE_LoadExtension|SQLITE_LoadExtFunc);
  }
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x40fd0f
callq *0x1904b1(%rip)         # 0x5a01c0
movl $0xfffcffff, %eax       # imm = 0xFFFCFFFF
andl 0x30(%rbx), %eax
testl %ebp, %ebp
movl $0x30000, %ecx          # imm = 0x30000
cmovel %ebp, %ecx
orl %eax, %ecx
movl %ecx, 0x30(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40fd35
callq *0x19049b(%rip)         # 0x5a01d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: createModule
static int createModule(
  sqlite3 *db,                    /* Database in which module is registered */
  const char *zName,              /* Name assigned to this module */
  const sqlite3_module *pModule,  /* The definition of the module */
  void *pAux,                     /* Context pointer for xCreate/xConnect */
  void (*xDestroy)(void *)        /* Module destructor function */
){
  int rc = SQLITE_OK;

  sqlite3_mutex_enter(db->mutex);
  if( sqlite3HashFind(&db->aModule, zName) ){
    rc = SQLITE_MISUSE_BKPT;
  }else{
    (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
  }
  rc = sqlite3ApiExit(db, rc);
  if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x410b5e
callq *0x18f662(%rip)         # 0x5a01c0
leaq 0x1c0(%r14), %rdi
xorl %r12d, %r12d
movq %rbp, %rsi
xorl %edx, %edx
callq 0x438fa0
cmpq $0x0, 0x10(%rax)
je 0x410ba7
leaq 0x13fd27(%rip), %rsi    # 0x5508a7
leaq 0x1440c9(%rip), %rdx    # 0x554c50
leaq 0x13fb50(%rip), %r8     # 0x5506de
movl $0x15, %r12d
movl $0x15, %edi
movl $0x206a5, %ecx          # imm = 0x206A5
xorl %eax, %eax
callq 0x40743a
jmp 0x410bbb
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x43bfae
cmpb $0x0, 0x61(%r14)
je 0x410bd2
movq %r14, %rdi
callq 0x42364d
movl $0x7, %r12d
jmp 0x410bd6
andl 0x54(%r14), %r12d
testl %r12d, %r12d
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x410beb
movq %r15, %rdi
callq *%rbx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x410bfa
callq *0x18f5d6(%rip)         # 0x5a01d0
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/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_vtab_collation
SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info *pIdxInfo, int iCons){
  HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
  const char *zRet = 0;
  if( iCons>=0 && iCons<pIdxInfo->nConstraint ){
    CollSeq *pC = 0;
    int iTerm = pIdxInfo->aConstraint[iCons].iTermOffset;
    Expr *pX = pHidden->pWC->a[iTerm].pExpr;
    if( pX->pLeft ){
      pC = sqlite3BinaryCompareCollSeq(pHidden->pParse, pX->pLeft, pX->pRight);
    }
    zRet = (pC ? pC->zName : sqlite3StrBINARY);
  }
  return zRet;
}

// Assembly:
testl %esi, %esi
js 0x411614
cmpl %esi, (%rdi)
jle 0x411614
pushq %rax
movl %esi, %eax
leaq (%rax,%rax,2), %rax
movq 0x8(%rdi), %rcx
movq 0x60(%rdi), %rdx
movslq 0x8(%rcx,%rax,4), %rax
movq 0x20(%rdx), %rcx
shlq $0x6, %rax
movq (%rcx,%rax), %rax
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x411617
movq 0x68(%rdi), %rdi
movq 0x18(%rax), %rdx
callq 0x41162f
jmp 0x411619
xorl %eax, %eax
retq
xorl %eax, %eax
testq %rax, %rax
je 0x411623
movq (%rax), %rax
jmp 0x41162a
leaq 0x13b5a6(%rip), %rax    # 0x54cbd0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3OsInit
SQLITE_PRIVATE int sqlite3OsInit(void){
  void *p = sqlite3_malloc(10);
  if( p==0 ) return SQLITE_NOMEM_BKPT;
  sqlite3_free(p);
  return sqlite3_os_init();
}

// Assembly:
pushq %rax
callq 0x404c3e
testl %eax, %eax
je 0x411e14
xorl %edi, %edi
jmp 0x411e21
movl $0xa, %edi
callq 0x4052d6
movq %rax, %rdi
testq %rdi, %rdi
je 0x411e34
callq 0x405420
callq 0x407800
xorl %eax, %eax
jmp 0x411e39
movl $0x7, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_set_last_insert_rowid
SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  db->lastRowid = iRowid;
  sqlite3_mutex_leave(db->mutex);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x412ba6
callq *0x18d61a(%rip)         # 0x5a01c0
movq %r14, 0x38(%rbx)
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x412bc0
popq %rbx
popq %r14
jmpq *0x18d610(%rip)         # 0x5a01d0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_busy_handler
SQLITE_API int sqlite3_busy_handler(
  sqlite3 *db,
  int (*xBusy)(void*,int),
  void *pArg
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->busyHandler.xBusyHandler = xBusy;
  db->busyHandler.pBusyArg = pArg;
  db->busyHandler.nBusy = 0;
  db->busyHandler.bExtraFileArg = 0;
  db->busyTimeout = 0;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x412d74
callq *0x18d44c(%rip)         # 0x5a01c0
movq %r15, 0x220(%rbx)
movq %r14, 0x228(%rbx)
xorl %eax, %eax
movl %eax, 0x230(%rbx)
movb $0x0, 0x234(%rbx)
movl %eax, 0x280(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x412da6
callq *0x18d42a(%rip)         # 0x5a01d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_trace
SQLITE_API void *sqlite3_trace(sqlite3 *db, void(*xTrace)(void*,const char*), void *pArg){
  void *pOld;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pTraceArg;
  db->mTrace = xTrace ? SQLITE_TRACE_LEGACY : 0;
  db->xTrace = (int(*)(u32,void*,void*,void*))xTrace;
  db->pTraceArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x413782
callq *0x18ca3e(%rip)         # 0x5a01c0
movq 0x18(%r14), %rdi
movq 0xe0(%r14), %r12
testq %r15, %r15
setne %al
shlb $0x7, %al
movb %al, 0x68(%r14)
movq %r15, 0xd8(%r14)
movq %rbx, 0xe0(%r14)
testq %rdi, %rdi
je 0x4137b3
callq *0x18ca1d(%rip)         # 0x5a01d0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_trace_v2
SQLITE_API int sqlite3_trace_v2(
  sqlite3 *db,                               /* Trace this connection */
  unsigned mTrace,                           /* Mask of events to be traced */
  int(*xTrace)(unsigned,void*,void*,void*),  /* Callback to invoke */
  void *pArg                                 /* Context */
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( mTrace==0 ) xTrace = 0;
  if( xTrace==0 ) mTrace = 0;
  db->mTrace = mTrace;
  db->xTrace = xTrace;
  db->pTraceArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x4137e3
callq *0x18c9dd(%rip)         # 0x5a01c0
xorl %eax, %eax
testl %ebp, %ebp
cmoveq %rax, %r15
testq %r15, %r15
cmovel %eax, %ebp
movb %bpl, 0x68(%r14)
movq %r15, 0xd8(%r14)
movq %rbx, 0xe0(%r14)
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x413812
callq *0x18c9be(%rip)         # 0x5a01d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_update_hook
SQLITE_API void *sqlite3_update_hook(
  sqlite3 *db,              /* Attach the hook to this database */
  void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
  void *pArg                /* Argument to the function */
){
  void *pRet;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pUpdateArg;
  db->xUpdateCallback = xCallback;
  db->pUpdateArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pRet;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x4138e5
callq *0x18c8db(%rip)         # 0x5a01c0
movq 0x18(%r14), %rdi
movq 0x118(%r14), %r12
movq %r15, 0x120(%r14)
movq %rbx, 0x118(%r14)
testq %rdi, %rdi
je 0x413909
callq *0x18c8c7(%rip)         # 0x5a01d0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/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
  while(1){
    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].zDbSName)==0 ){
        assert( sqlite3SchemaMutexHeld(db, j, 0) );
        p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
        if( p ) return p;
      }
    }
    /* Not found.  If the name we were looking for was temp.sqlite_master
    ** then change the name to sqlite_temp_master and try again. */
    if( sqlite3StrICmp(zName, MASTER_NAME)!=0 ) break;
    if( sqlite3_stricmp(zDatabase, db->aDb[1].zDbSName)!=0 ) break;
    zName = TEMP_MASTER_NAME;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movl 0x28(%rdi), %r14d
testl %r14d, %r14d
jle 0x414e6e
xorl %r15d, %r15d
movq %rbp, %r13
xorl %eax, %eax
cmpl $0x2, %r15d
setb %al
xorl %r15d, %eax
movl %eax, %ebp
testq %rbx, %rbx
je 0x414e2a
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rbp, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %rbx, %rdi
callq 0x407729
testl %eax, %eax
jne 0x414e58
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
shlq $0x5, %rbp
movq 0x18(%rax,%rbp), %rdi
addq $0x8, %rdi
xorl %r12d, %r12d
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x438fa0
movq 0x10(%rax), %rbp
testq %rbp, %rbp
jne 0x414e5e
movb $0x1, %r12b
movq %r13, %rbp
testb %r12b, %r12b
je 0x414ecb
incl %r15d
movq %rbp, %r13
cmpl %r15d, %r14d
jne 0x414df7
movq 0x8(%rsp), %rdi
leaq 0x13c392(%rip), %rsi    # 0x55120c
callq 0x407729
testl %eax, %eax
jne 0x414ec9
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rsi
testq %rbx, %rbx
je 0x414ea4
testq %rsi, %rsi
je 0x414eb0
movq %rbx, %rdi
callq 0x407729
jmp 0x414eb5
negq %rsi
movl $0x0, %eax
sbbl %eax, %eax
jmp 0x414eb5
movl $0x1, %eax
leaq 0x13c454(%rip), %rcx    # 0x551310
movq %rcx, 0x8(%rsp)
testl %eax, %eax
je 0x414dec
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3DbRealloc
SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
  assert( db!=0 );
  if( p==0 ) return sqlite3DbMallocRawNN(db, n);
  assert( sqlite3_mutex_held(db->mutex) );
  if( isLookaside(db,p) && n<=db->lookaside.sz ) return p;
  return dbReallocFinish(db, p, n);
}

// Assembly:
testq %rsi, %rsi
je 0x415e6c
cmpq %rsi, 0x188(%rdi)
ja 0x415edc
cmpq %rsi, 0x190(%rdi)
jbe 0x415edc
movzwl 0x164(%rdi), %eax
cmpq %rdx, %rax
jb 0x415edc
movq %rsi, %rax
retq
movq %rdx, %rsi
jmp 0x415e71
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: dbReallocFinish
static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){
  void *pNew = 0;
  assert( db!=0 );
  assert( p!=0 );
  if( db->mallocFailed==0 ){
    if( isLookaside(db, p) ){
      pNew = sqlite3DbMallocRawNN(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 ){
        sqlite3OomFault(db);
      }
      sqlite3MemdebugSetType(pNew,
            (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
    }
  }
  return pNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x61(%rdi)
je 0x415ef3
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rsi, 0x188(%rdi)
ja 0x415f45
cmpq %r15, 0x190(%rbx)
jbe 0x415f45
movq %rbx, %rdi
movq %r14, %rsi
callq 0x415e71
testq %rax, %rax
je 0x415ee7
movq %rax, %r14
movzwl 0x164(%rbx), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x401048
testq %r15, %r15
je 0x415eea
movq %rbx, %rdi
movq %r15, %rsi
callq 0x415dca
jmp 0x415eea
callq 0x404c3e
testl %eax, %eax
je 0x415f53
xorl %r14d, %r14d
jmp 0x415f61
movq %r15, %rdi
movq %r14, %rsi
callq 0x4054bc
movq %rax, %r14
testq %r14, %r14
jne 0x415eea
cmpb $0x0, 0x61(%rbx)
jne 0x415ee7
cmpb $0x0, 0x62(%rbx)
jne 0x415ee7
movb $0x1, 0x61(%rbx)
cmpl $0x0, 0xc4(%rbx)
jle 0x415f91
movl $0x1, 0x158(%rbx)
incl 0x160(%rbx)
jmp 0x415ee7
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: unixShmBarrier
static void unixShmBarrier(
  sqlite3_file *fd                /* Database file holding the shared memory */
){
  UNUSED_PARAMETER(fd);
  sqlite3MemoryBarrier();         /* compiler-defined memory barrier */
  assert( fd->pMethods->xLock==nolockLock 
       || unixFileMutexNotheld((unixFile*)fd) 
  );
  unixEnterMutex();               /* Also mutex, for redundancy */
  unixLeaveMutex();
}

// Assembly:
pushq %rax
mfence
movq 0x18d408(%rip), %rdi    # 0x5a4a48
testq %rdi, %rdi
je 0x41764b
callq *0x188b75(%rip)         # 0x5a01c0
movq 0x18d3f6(%rip), %rdi    # 0x5a4a48
testq %rdi, %rdi
je 0x41765e
popq %rax
jmpq *0x188b72(%rip)         # 0x5a01d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreeEnterAll
static void SQLITE_NOINLINE btreeEnterAll(sqlite3 *db){
  int i;
  int skipOk = 1;
  Btree *p;
  assert( sqlite3_mutex_held(db->mutex) );
  for(i=0; i<db->nDb; i++){
    p = db->aDb[i].pBt;
    if( p && p->sharable ){
      sqlite3BtreeEnter(p);
      skipOk = 0;
    }
  }
  db->noSharedCache = skipOk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
jle 0x418318
movl $0x1, %ebp
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x418306
cmpb $0x0, 0x11(%rdi)
je 0x418306
incl 0x14(%rdi)
xorl %ebp, %ebp
cmpb $0x0, 0x12(%rdi)
jne 0x418306
callq 0x42017c
incq %r15
movslq 0x28(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x4182e3
jmp 0x41831b
movb $0x1, %bpl
movb %bpl, 0x69(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreeLeaveAll
static void SQLITE_NOINLINE btreeLeaveAll(sqlite3 *db){
  int i;
  Btree *p;
  assert( sqlite3_mutex_held(db->mutex) );
  for(i=0; i<db->nDb; i++){
    p = db->aDb[i].pBt;
    if( p ) sqlite3BtreeLeave(p);
  }
}

// Assembly:
cmpl $0x0, 0x28(%rdi)
jle 0x418373
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x41835e
cmpb $0x0, 0x11(%rdi)
je 0x41835e
decl 0x14(%rdi)
jne 0x41835e
callq 0x420202
incq %r15
movslq 0x28(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x418341
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: walIndexPageRealloc
static SQLITE_NOINLINE int walIndexPageRealloc(
  Wal *pWal,               /* The WAL context */
  int iPage,               /* The page we seek */
  volatile u32 **ppPage    /* Write the page pointer here */
){
  int rc = SQLITE_OK;

  /* Enlarge the pWal->apWiData[] array if required */
  if( pWal->nWiData<=iPage ){
    int nByte = sizeof(u32*)*(iPage+1);
    volatile u32 **apNew;
    apNew = (volatile u32 **)sqlite3_realloc64((void *)pWal->apWiData, nByte);
    if( !apNew ){
      *ppPage = 0;
      return SQLITE_NOMEM_BKPT;
    }
    memset((void*)&apNew[pWal->nWiData], 0,
           sizeof(u32*)*(iPage+1-pWal->nWiData));
    pWal->apWiData = apNew;
    pWal->nWiData = iPage+1;
  }

  /* Request a pointer to the required page from the VFS */
  assert( pWal->apWiData[iPage]==0 );
  if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
    pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
    if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT;
  }else{
    rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ, 
        pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
    );
    assert( pWal->apWiData[iPage]!=0 || rc!=SQLITE_OK || pWal->writeLock==0 );
    testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
    if( (rc&0xff)==SQLITE_READONLY ){
      pWal->readOnly |= WAL_SHM_RDONLY;
      if( rc==SQLITE_READONLY ){
        rc = SQLITE_OK;
      }
    }
  }

  *ppPage = pWal->apWiData[iPage];
  assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r15
cmpl %esi, 0x28(%rdi)
jg 0x41c115
leaq 0x1(%r15), %r13
movq 0x30(%r14), %r12
callq 0x404c3e
testl %eax, %eax
je 0x41c0c7
xorl %r12d, %r12d
jmp 0x41c0dd
leal (,%r13,8), %eax
movslq %eax, %rsi
movq %r12, %rdi
callq 0x4054bc
movq %rax, %r12
testq %r12, %r12
je 0x41c105
movslq 0x28(%r14), %rax
leaq (%r12,%rax,8), %rdi
movq %r13, %rdx
subq %rax, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x4010b8
movq %r12, 0x30(%r14)
movl %r13d, 0x28(%r14)
jmp 0x41c10c
movq $0x0, (%rbx)
testq %r12, %r12
je 0x41c1a3
cmpb $0x2, 0x3f(%r14)
jne 0x41c15a
movl $0x8000, %edi           # imm = 0x8000
callq 0x4052d6
movq %rax, %r12
testq %rax, %rax
je 0x41c13d
movl $0x8000, %edx           # imm = 0x8000
movq %r12, %rdi
xorl %esi, %esi
callq 0x4010b8
movq 0x30(%r14), %rax
movq %r12, (%rax,%r15,8)
movq 0x30(%r14), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%r15,8)
movl $0x7, %eax
cmovnel %ecx, %eax
jmp 0x41c18e
movq 0x8(%r14), %rdi
movzbl 0x40(%r14), %ecx
leaq (,%r15,8), %r8
addq 0x30(%r14), %r8
movq (%rdi), %rax
movl %r15d, %esi
movl $0x8000, %edx           # imm = 0x8000
callq *0x68(%rax)
cmpb $0x8, %al
jne 0x41c18e
orb $0x2, 0x42(%r14)
xorl %ecx, %ecx
cmpl $0x8, %eax
cmovel %ecx, %eax
movq 0x30(%r14), %rcx
movq (%rcx,%r15,8), %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x7, %eax
jmp 0x41c199
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: saveCursorKey
static int saveCursorKey(BtCursor *pCur){
  int rc = SQLITE_OK;
  assert( CURSOR_VALID==pCur->eState );
  assert( 0==pCur->pKey );
  assert( cursorHoldsMutex(pCur) );

  if( pCur->curIntKey ){
    /* Only the rowid is required for a table btree */
    pCur->nKey = sqlite3BtreeIntegerKey(pCur);
  }else{
    /* For an index btree, save the complete key content */
    void *pKey;
    pCur->nKey = sqlite3BtreePayloadSize(pCur);
    pKey = sqlite3Malloc( pCur->nKey );
    if( pKey ){
      rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
      if( rc==SQLITE_OK ){
        pCur->pKey = pKey;
      }else{
        sqlite3_free(pKey);
      }
    }else{
      rc = SQLITE_NOMEM_BKPT;
    }
  }
  assert( !pCur->curIntKey || !pCur->pKey );
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x55(%rdi), %bpl
callq 0x421a8b
testb %bpl, %bpl
je 0x421a41
movq 0x30(%rbx), %rax
movq %rax, 0x48(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x40(%rbx), %edi
movq %rdi, 0x48(%rbx)
callq 0x4052d6
testq %rax, %rax
je 0x421a7e
movq %rax, %r14
movl 0x48(%rbx), %edx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x421ad1
testl %eax, %eax
je 0x421a85
movl %eax, %r15d
movq %r14, %rdi
callq 0x405420
movl %r15d, %ebp
jmp 0x421a34
movl $0x7, %ebp
jmp 0x421a34
movq %r14, 0x18(%rbx)
jmp 0x421a34
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: apiOomError
SQLITE_PRIVATE void sqlite3OomClear(sqlite3 *db){
  if( db->mallocFailed && db->nVdbeExec==0 ){
    db->mallocFailed = 0;
    db->u1.isInterrupted = 0;
    assert( db->lookaside.bDisable>0 );
    db->lookaside.bDisable--;
  }
}

// Assembly:
cmpb $0x0, 0x61(%rdi)
je 0x423670
cmpl $0x0, 0xc4(%rdi)
jne 0x423670
movb $0x0, 0x61(%rdi)
movl $0x0, 0x158(%rdi)
decl 0x160(%rdi)
movl $0x7, 0x50(%rdi)
movl $0x7, %esi
jmp 0x4183f3
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VdbeMemGrow
int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
  assert( sqlite3VdbeCheckMemInvariants(pMem) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  testcase( pMem->db==0 );

  /* If the bPreserve flag is set to true, then the memory cell must already
  ** contain a valid string or blob value.  */
  assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
  testcase( bPreserve && pMem->z==0 );

  assert( pMem->szMalloc==0
       || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) );
  if( n<32 ) n = 32;
  if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){
    pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
    bPreserve = 0;
  }else{
    if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
    pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
  }
  if( pMem->zMalloc==0 ){
    sqlite3VdbeMemSetNull(pMem);
    pMem->z = 0;
    pMem->szMalloc = 0;
    return SQLITE_NOMEM_BKPT;
  }else{
    pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
  }

  if( bPreserve && pMem->z ){
    assert( pMem->z!=pMem->zMalloc );
    memcpy(pMem->zMalloc, pMem->z, pMem->n);
  }
  if( (pMem->flags&MEM_Dyn)!=0 ){
    assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
    pMem->xDel((void *)(pMem->z));
  }

  pMem->z = pMem->zMalloc;
  pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
cmpl $0x21, %esi
movl $0x20, %r14d
cmovgel %esi, %r14d
movl 0x20(%rdi), %eax
testl %eax, %eax
setle %cl
testl %edx, %edx
sete %dl
orb %cl, %dl
jne 0x425157
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x42520b
testl %eax, %eax
jle 0x425168
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0x415dca
movq 0x28(%rbx), %rdi
movl %r14d, %esi
testq %rdi, %rdi
je 0x42517b
callq 0x415e71
jmp 0x425183
movq %rsi, %rdi
callq 0x4052d6
movq %rax, 0x18(%rbx)
testl %ebp, %ebp
sete %bpl
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4251fb
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x4251ba
cmpq %rdi, 0x188(%rax)
ja 0x4251ba
cmpq %rdi, 0x190(%rax)
jbe 0x4251ba
movzwl 0x164(%rax), %eax
jmp 0x4251c0
callq *0x17afb8(%rip)         # 0x5a0178
movl %eax, 0x20(%rbx)
testb %bpl, %bpl
jne 0x4251de
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x4251de
movq 0x18(%rbx), %rdi
movslq 0xc(%rbx), %rdx
callq 0x401048
testb $0x4, 0x9(%rbx)
je 0x4251eb
movq 0x10(%rbx), %rdi
callq *0x30(%rbx)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
andb $-0x1d, 0x9(%rbx)
xorl %eax, %eax
jmp 0x425241
testb $0x24, 0x9(%rbx)
je 0x425227
movq %rbx, %rdi
callq 0x425064
jmp 0x42522d
movq 0x28(%rbx), %rdi
movl %r14d, %edx
callq 0x425246
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movb $0x1, %bpl
jmp 0x42518d
movw $0x1, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movl $0x7, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VdbeAllocUnpackedRecord
SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(
  KeyInfo *pKeyInfo               /* Description of the record */
){
  UnpackedRecord *p;              /* Unpacked record to return */
  int nByte;                      /* Number of bytes required for *p */
  nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
  p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
  if( !p ) return 0;
  p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
  assert( pKeyInfo->aSortOrder!=0 );
  p->pKeyInfo = pKeyInfo;
  p->nField = pKeyInfo->nKeyField + 1;
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0x6(%rdi), %eax
imulq $0x38, %rax, %rsi
addq $0x50, %rsi
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x4305ac
callq 0x415e71
jmp 0x4305b4
movq %rsi, %rdi
callq 0x4052d6
testq %rax, %rax
je 0x4305d0
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movq %rbx, (%rax)
movzwl 0x6(%rbx), %ecx
incl %ecx
movw %cx, 0x10(%rax)
jmp 0x4305d2
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VdbeMemNumerify
SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
  if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
    int rc;
    assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
    assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
    rc = sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc);
    if( rc==0 ){
      MemSetTypeFlag(pMem, MEM_Int);
    }else{
      i64 i = pMem->u.i;
      sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
      if( rc==1 && sqlite3RealSameAsInt(pMem->u.r, i) ){
        pMem->u.i = i;
        MemSetTypeFlag(pMem, MEM_Int);
      }else{
        MemSetTypeFlag(pMem, MEM_Real);
      }
    }
  }
  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
  pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb $0xd, 0x8(%rdi)
jne 0x43276b
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movq %rbx, %rsi
callq 0x425f82
movl %eax, %ebp
movw $0x4, %ax
testl %ebp, %ebp
je 0x432758
movq (%rbx), %r14
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movq %rbx, %rsi
callq 0x425a36
movw $0x8, %ax
cmpl $0x1, %ebp
jne 0x432758
cvtsi2sd %r14, %xmm0
movq %xmm0, %rcx
cmpq %rcx, (%rbx)
jne 0x432758
movq %r14, (%rbx)
movw $0x4, %ax
movzwl 0x8(%rbx), %ecx
andl $0x3e00, %ecx           # imm = 0x3E00
movzwl %ax, %eax
orl %ecx, %eax
movw %ax, 0x8(%rbx)
andw $0xbfed, 0x8(%rbx)      # imm = 0xBFED
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreeMoveto
static int btreeMoveto(
  BtCursor *pCur,     /* Cursor open on the btree to be searched */
  const void *pKey,   /* Packed key if the btree is an index */
  i64 nKey,           /* Integer key for tables.  Size of pKey for indices */
  int bias,           /* Bias search to the high end */
  int *pRes           /* Write search results here */
){
  int rc;                    /* Status code */
  UnpackedRecord *pIdxKey;   /* Unpacked index key */

  if( pKey ){
    assert( nKey==(i64)(int)nKey );
    pIdxKey = sqlite3VdbeAllocUnpackedRecord(pCur->pKeyInfo);
    if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT;
    sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
    if( pIdxKey->nField==0 ){
      rc = SQLITE_CORRUPT_BKPT;
      goto moveto_done;
    }
  }else{
    pIdxKey = 0;
  }
  rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
moveto_done:
  if( pIdxKey ){
    sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
testq %rsi, %rsi
je 0x432ac1
movq %rsi, %r13
movq 0x80(%rbx), %rdi
callq 0x43058c
testq %rax, %rax
je 0x432af3
movq %rax, %r14
movq 0x80(%rbx), %rdi
movl %r12d, %esi
movq %r13, %rdx
movq %rax, %rcx
callq 0x4305d4
cmpw $0x0, 0x10(%r14)
jne 0x432ac4
leaq 0x11de0c(%rip), %rsi    # 0x5508a7
leaq 0x11df28(%rip), %rdx    # 0x5509ca
leaq 0x11dc35(%rip), %r8     # 0x5506de
movl $0xb, %ebp
movl $0xb, %edi
movl $0xf7e4, %ecx           # imm = 0xF7E4
xorl %eax, %eax
callq 0x40743a
jmp 0x432ad9
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq %r15, %r8
callq 0x42ff0c
movl %eax, %ebp
testq %r14, %r14
je 0x432af8
movq 0x80(%rbx), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x415dca
jmp 0x432af8
movl $0x7, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreePrevious
static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
  int rc;
  MemPage *pPage;

  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
  assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
  assert( pCur->info.nSize==0 );
  if( pCur->eState!=CURSOR_VALID ){
    rc = restoreCursorPosition(pCur);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    if( CURSOR_INVALID==pCur->eState ){
      return SQLITE_DONE;
    }
    if( pCur->skipNext ){
      assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
      pCur->eState = CURSOR_VALID;
      if( pCur->skipNext<0 ){
        pCur->skipNext = 0;
        return SQLITE_OK;
      }
      pCur->skipNext = 0;
    }
  }

  pPage = pCur->pPage;
  assert( pPage->isInit );
  if( !pPage->leaf ){
    int idx = pCur->ix;
    rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
    if( rc ) return rc;
    rc = moveToRightmost(pCur);
  }else{
    while( pCur->ix==0 ){
      if( pCur->iPage==0 ){
        pCur->eState = CURSOR_INVALID;
        return SQLITE_DONE;
      }
      moveToParent(pCur);
    }
    assert( pCur->info.nSize==0 );
    assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );

    pCur->ix--;
    pPage = pCur->pPage;
    if( pPage->intKey && !pPage->leaf ){
      rc = sqlite3BtreePrevious(pCur, 0);
    }else{
      rc = SQLITE_OK;
    }
  }
  return rc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x433af4
xorl %eax, %eax
cmpb $0x3, %cl
jb 0x433ac7
movq %rbx, %rdi
callq 0x4329e8
testl %eax, %eax
jne 0x433b84
movl $0x65, %eax
cmpb $0x1, (%rbx)
je 0x433b84
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x433af4
movb $0x0, (%rbx)
movl $0x0, 0x4(%rbx)
js 0x433b82
movq 0x88(%rbx), %rcx
cmpb $0x0, 0x8(%rcx)
movzwl 0x56(%rbx), %eax
je 0x433b42
testw %ax, %ax
jne 0x433b1e
cmpb $0x0, 0x54(%rbx)
je 0x433b78
movq %rbx, %rdi
callq 0x432dd8
movzwl 0x56(%rbx), %eax
jmp 0x433b05
decl %eax
movw %ax, 0x56(%rbx)
movq 0x88(%rbx), %rcx
xorl %eax, %eax
cmpb $0x0, 0x2(%rcx)
je 0x433b84
cmpb $0x0, 0x8(%rcx)
jne 0x433b84
movq %rbx, %rdi
popq %rbx
jmp 0x430552
movzwl %ax, %eax
movzwl 0x18(%rcx), %edx
movq 0x50(%rcx), %rsi
movq 0x60(%rcx), %rcx
movzbl (%rcx,%rax,2), %edi
shll $0x8, %edi
movzbl 0x1(%rcx,%rax,2), %eax
orl %edi, %eax
andl %edx, %eax
movl (%rsi,%rax), %esi
bswapl %esi
movq %rbx, %rdi
callq 0x432e18
testl %eax, %eax
jne 0x433b84
movq %rbx, %rdi
popq %rbx
jmp 0x433b86
movb $0x1, (%rbx)
movl $0x65, %eax
jmp 0x433b84
xorl %eax, %eax
popq %rbx
retq