LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/random.c
// Function: rand_gen_generate
char* rand_gen_generate(RandomGenerator* gen_, int len) {
  if (gen_->pos_ + len > gen_->data_size_) {
    gen_->pos_ = 0;
    assert(len < gen_->data_size_);
  }
  gen_->pos_ += len;
  char* substr = malloc(sizeof(char) * (len + 1));
  strncpy(substr, (gen_->data_) + gen_->pos_ - len, len);

  return substr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
leal (%r15,%rsi), %eax
movslq %eax, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
jae 0x403b57
andl $0x0, 0x10(%rbx)
movslq %esi, %r14
xorl %r15d, %r15d
cmpq %r14, %rax
ja 0x403b5a
leaq 0x13563a(%rip), %rdi    # 0x53917b
leaq 0x13564a(%rip), %rsi    # 0x539192
leaq 0x13564c(%rip), %rcx    # 0x53919b
pushq $0x5b
popq %rdx
callq 0x46db40
movslq %esi, %r14
addl %esi, %r15d
movl %r15d, 0x10(%rbx)
incl %esi
movslq %esi, %rdi
callq 0x495830
movslq %r15d, %rsi
addq (%rbx), %rsi
subq %r14, %rsi
movq %rax, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x401098
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/raw.c
// Function: raw_add
void raw_add(Raw *raw_, double value) {
  if (!raw_->data_)
    raw_calloc(raw_);
  if (raw_->data_size_ < raw_->pos_ + 1)
    raw_realloc(raw_);
  raw_->data_[raw_->pos_] = value;
  raw_->pos_++;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
jne 0x403bdf
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x403b96
movsd 0x8(%rsp), %xmm0
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rdx, %rsi
jae 0x403c1e
movsd %xmm0, 0x8(%rsp)
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x495ec0
movq %rax, (%rbx)
testq %rax, %rax
je 0x403c2f
movl 0x10(%rbx), %ecx
leal 0x1(%rcx), %edx
movsd 0x8(%rsp), %xmm0
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl %edx, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq $0x5956a8, %rax         # imm = 0x5956A8
movq (%rax), %rcx
leaq 0x13559e(%rip), %rdi    # 0x5391de
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x4839c0
pushq $0x1
popq %rdi
callq 0x4742a0
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/raw.c
// Function: raw_to_string
char* raw_to_string(Raw *raw_) {
  if (!raw_->data_)
    raw_calloc(raw_);
  size_t r_size = 1024;
  char *r = malloc(sizeof(char) * r_size);
  strcpy(r, "");
  char buf[200];
  for (int i = 0; i < raw_->pos_; i++) {
    snprintf(buf, sizeof(buf), "%.4f\n", raw_->data_[i]);
    if (r_size < strlen(r) + strlen(buf)) {
      r = realloc(r, r_size * 2);
      r_size *= 2;
    }
    strcat(r, buf);
  }
  return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x403c75
movq %rbx, %rdi
callq 0x403b96
movl $0x400, %r14d           # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x495830
movq %rax, %r15
movb $0x0, (%rax)
xorl %r12d, %r12d
movq %rsp, %r13
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jge 0x403cf5
movq (%rbx), %rax
movsd (%rax,%r12,8), %xmm0
movl $0xc8, %esi
movq %r13, %rdi
leaq 0x134d76(%rip), %rdx    # 0x538a28
movb $0x1, %al
callq 0x474e90
movq %r15, %rdi
callq 0x401100
movq %rax, %rbp
movq %r13, %rdi
callq 0x401100
addq %rbp, %rax
cmpq %rax, %r14
jae 0x403ce5
addq %r14, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x495ec0
movq %rax, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x401068
incq %r12
jmp 0x403c91
movq %r15, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/raw.c
// Function: raw_print
void raw_print(FILE *stream, Raw *raw_) {
  if (!raw_->data_)
    raw_calloc(raw_);
  fprintf(stream, "num,time\n");
  for (int i = 0; i < raw_->pos_; i++)
    fprintf(stream, "%d,%.4f\n", i, raw_->data_[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rsi)
jne 0x403d26
movq %rbx, %rdi
callq 0x403b96
leaq 0x13549e(%rip), %rdi    # 0x5391cb
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x4839c0
xorl %r15d, %r15d
leaq 0x135490(%rip), %r12    # 0x5391d5
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jge 0x403d6c
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
movb $0x1, %al
callq 0x474dd0
incq %r15
jmp 0x403d45
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3LookasideUsed
SQLITE_PRIVATE int sqlite3LookasideUsed(sqlite3 *db, int *pHighwater){
  u32 nInit = countLookasideSlots(db->lookaside.pInit);
  u32 nFree = countLookasideSlots(db->lookaside.pFree);
  if( pHighwater ) *pHighwater = db->lookaside.nSlot - nInit;
  return db->lookaside.nSlot - (nInit+nFree);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x178(%rdi), %rdi
callq 0x412e45
movl %eax, %ebp
movq 0x180(%rbx), %rdi
callq 0x412e45
testq %r14, %r14
je 0x404270
movl 0x168(%rbx), %ecx
subl %ebp, %ecx
movl %ecx, (%r14)
movl 0x168(%rbx), %ecx
addl %ebp, %eax
subl %eax, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VdbeClearObject
SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
  SubProgram *pSub, *pNext;
  assert( p->db==0 || p->db==db );
  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  for(pSub=p->pProgram; pSub; pSub=pNext){
    pNext = pSub->pNext;
    vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
    sqlite3DbFree(db, pSub);
  }
  if( p->magic!=VDBE_MAGIC_INIT ){
    releaseMemArray(p->aVar, p->nVar);
    sqlite3DbFree(db, p->pVList);
    sqlite3DbFree(db, p->pFree);
  }
  vdbeFreeOpArray(db, p->aOp, p->nOp);
  sqlite3DbFree(db, p->aColName);
  sqlite3DbFree(db, p->zSql);
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  {
    int i;
    for(i=0; i<p->nScan; i++){
      sqlite3DbFree(db, p->aScan[i].zName);
    }
    sqlite3DbFree(db, p->aScan);
  }
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rdi
movzwl 0xbc(%rsi), %esi
addl %esi, %esi
callq 0x41e6dc
movq 0x110(%r14), %r15
testq %r15, %r15
je 0x40437b
movq 0x28(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x41e763
movq %rbx, %rdi
movq %r15, %rsi
callq 0x412f53
movq %r12, %r15
jmp 0x404353
cmpl $0x16bceaa5, 0x24(%r14) # imm = 0x16BCEAA5
je 0x4043b4
movq 0xa0(%r14), %rdi
movswl 0x20(%r14), %esi
callq 0x41e6dc
movq 0xa8(%r14), %rsi
movq %rbx, %rdi
callq 0x4043ed
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
callq 0x4043ed
movq 0x68(%r14), %rsi
movl 0xb8(%r14), %edx
movq %rbx, %rdi
callq 0x41e763
movq 0x80(%r14), %rsi
movq %rbx, %rdi
callq 0x4043ed
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4043ed
// File: /workspace/github_c_makefile_star2_O2/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 0x404943
callq 0x404482
jmp 0x404948
callq 0x404959
testl %eax, %eax
je 0x404950
xorl %eax, %eax
popq %rbx
retq
movl %ebx, %edi
popq %rbx
jmpq *0x18e857(%rip)         # 0x5931b0
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
leaq 0x1336f8(%rip), %rcx    # 0x53a3b0
movzbl (%rdi,%rax), %r9d
movb (%r9,%rcx), %dl
movzbl (%rsi,%rax), %r8d
movb (%r8,%rcx), %r8b
testq %r9, %r9
je 0x406cd9
cmpb %r8b, %dl
jne 0x406cd9
incq %rax
jmp 0x406cb8
movzbl %dl, %eax
movzbl %r8b, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x404281
pushq $0x18
popq %r14
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0x408c0e
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x408c05
callq 0x42a33c
incq %r15
addq $0x20, %r14
jmp 0x408bea
andb $-0xa, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x4334b4
movq %rbx, %rdi
callq 0x40428c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4334ef
// File: /workspace/github_c_makefile_star2_O2/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 0x409049
movq %rsi, %rdx
pushq $0x15
popq %rsi
callq *0x50(%rax)
cmpl $0xc, %eax
je 0x409049
testl %eax, %eax
jne 0x409051
xorl %eax, %eax
cmpb $0x0, 0xb(%rbx)
je 0x409053
popq %rbx
retq
movzbl 0xe(%rbx), %esi
testl %esi, %esi
je 0x409051
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 0x41e8c3
movq (%r15), %rax
subq 0xb0(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
movq %rdx, (%rsp)
movq 0xe8(%r14), %rax
testq %rax, %rax
je 0x409782
movq 0xf0(%r14), %rdi
movq 0xe8(%rbx), %rsi
callq *%rax
testb $0x2, 0x68(%r14)
je 0x4097a0
movq 0xe0(%r14), %rsi
pushq $0x2
popq %rdi
movq %rsp, %rcx
movq %rbx, %rdx
callq *0xd8(%r14)
andq $0x0, 0xb0(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdx
cmovll %edx, %esi
callq 0x42006d
testl %eax, %eax
je 0x409a43
pushq $0x7
popq %rbp
jmp 0x409a60
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_O2/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 0x409aca
testb $0x4, %al
jne 0x409acf
testb $0x12, %al
jne 0x4208ab
xorps %xmm0, %xmm0
retq
movsd (%rdi), %xmm0
retq
cvtsi2sdq (%rdi), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3OomFault
SQLITE_PRIVATE void sqlite3OomFault(sqlite3 *db){
  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
    db->mallocFailed = 1;
    if( db->nVdbeExec>0 ){
      db->u1.isInterrupted = 1;
    }
    db->lookaside.bDisable++;
  }
}

// Assembly:
cmpb $0x0, 0x61(%rdi)
je 0x40a205
retq
cmpb $0x0, 0x62(%rdi)
jne 0x40a204
movb $0x1, 0x61(%rdi)
cmpl $0x0, 0xc4(%rdi)
jle 0x40a222
movl $0x1, 0x158(%rdi)
incl 0x160(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: columnMallocFailure
static void columnMallocFailure(sqlite3_stmt *pStmt)
{
  /* If malloc() failed during an encoding conversion within an
  ** sqlite3_column_XXX API, then set the return code of the statement to
  ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
  ** and _finalize() will return NOMEM.
  */
  Vdbe *p = (Vdbe *)pStmt;
  if( p ){
    assert( p->db!=0 );
    assert( sqlite3_mutex_held(p->db->mutex) );
    p->rc = sqlite3ApiExit(p->db, p->rc);
    sqlite3_mutex_leave(p->db->mutex);
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x40b049
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x38(%rbx), %esi
callq 0x4097e6
movl %eax, 0x38(%rbx)
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x40b049
popq %rbx
jmpq *0x188187(%rip)         # 0x5931d0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x40b96d
callq *0x187859(%rip)         # 0x5931c0
movq 0x18(%rbx), %rdi
jmp 0x40b96f
xorl %edi, %edi
addq $0x8, %rbx
leaq 0x10(%r14), %rax
testq %r14, %r14
cmoveq %rbx, %rax
movq (%rax), %rbx
testq %rdi, %rdi
je 0x40b98c
callq *0x187844(%rip)         # 0x5931d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
testq %rdi, %rdi
je 0x40ba75
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
testq %r14, %r14
je 0x40ba75
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x40ba53
callq *0x18776d(%rip)         # 0x5931c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40ba83
movq %rax, %r14
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x40ba78
callq *0x18775d(%rip)         # 0x5931d0
jmp 0x40ba78
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4208d9
testl %eax, %eax
je 0x40bea6
movq %rsp, %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x420cca
testl %eax, %eax
je 0x40be90
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl 0x8(%rbx), %eax
orl $0x8, %eax
movw %ax, 0x8(%rbx)
testl %ebp, %ebp
je 0x40be9d
movq %rbx, %rdi
callq 0x428765
movzwl 0x8(%rbx), %eax
jmp 0x40be9d
movq (%rsp), %rax
movq %rax, (%rbx)
movl 0x8(%rbx), %eax
orl $0x4, %eax
andl $0xfffd, %eax           # imm = 0xFFFD
movw %ax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %r14, %rdi
callq 0x4043ed
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0x430b76
testq %r14, %r14
je 0x40ce12
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_O2/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 0x40d8bd
movq %rdi, %rbx
callq 0x4112f7
testl %eax, %eax
je 0x40d8c6
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40d8ae
callq *0x185912(%rip)         # 0x5931c0
cmpb $0x0, 0x61(%rbx)
je 0x40d8de
leaq 0x131a57(%rip), %r14    # 0x53f312
jmp 0x40d8fd
leaq 0x131a4e(%rip), %r14    # 0x53f312
jmp 0x40d90c
movl $0x25a2f, %edi          # imm = 0x25A2F
callq 0x403dfd
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40a16f
movq 0x150(%rbx), %rdi
callq 0x409a69
movq %rax, %r14
testq %rax, %rax
jne 0x40d8fd
movl 0x50(%rbx), %edi
callq 0x40a16f
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40d90c
callq *0x1858c4(%rip)         # 0x5931d0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x40dd22
callq *0x18549e(%rip)         # 0x5931c0
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 0x40dd48
callq *0x185488(%rip)         # 0x5931d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_auto_extension
SQLITE_API int sqlite3_auto_extension(
  void (*xInit)(void)
){
  int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ){
    return rc;
  }else
#endif
  {
    u32 i;
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);
    for(i=0; i<wsdAutoext.nExt; i++){
      if( wsdAutoext.aExt[i]==xInit ) break;
    }
    if( i==wsdAutoext.nExt ){
      u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
      void (**aNew)(void);
      aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);
      if( aNew==0 ){
        rc = SQLITE_NOMEM_BKPT;
      }else{
        wsdAutoext.aExt = aNew;
        wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
        wsdAutoext.nExt++;
      }
    }
    sqlite3_mutex_leave(mutex);
    assert( (rc&0xff)==rc );
    return rc;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x404482
movl %eax, %ebp
testl %eax, %eax
jne 0x40ddfc
movb $0x1, %r15b
cmpl $0x0, 0x1853c0(%rip)    # 0x593134
je 0x40dd95
pushq $0x2
popq %rdi
callq *0x185431(%rip)         # 0x5931b0
testq %rax, %rax
je 0x40dd95
movq %rax, %r14
movq %rax, %rdi
callq *0x185430(%rip)         # 0x5931c0
xorl %r15d, %r15d
jmp 0x40dd98
xorl %r14d, %r14d
movl 0x189cb2(%rip), %esi    # 0x597a50
movq 0x189cb3(%rip), %rdi    # 0x597a58
xorl %eax, %eax
cmpq %rax, %rsi
je 0x40ddbd
cmpq %rbx, (%rdi,%rax,8)
je 0x40ddb7
incq %rax
jmp 0x40dda7
xorl %ebp, %ebp
cmpl %eax, %esi
jne 0x40ddee
incl %esi
shlq $0x3, %rsi
callq 0x404e52
testq %rax, %rax
je 0x40ddeb
movq %rax, 0x189c84(%rip)    # 0x597a58
movl 0x189c76(%rip), %ecx    # 0x597a50
movq %rbx, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x189c69(%rip)    # 0x597a50
xorl %ebp, %ebp
jmp 0x40ddee
pushq $0x7
popq %rbp
testb %r15b, %r15b
jne 0x40ddfc
movq %r14, %rdi
callq *0x1853d4(%rip)         # 0x5931d0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x40e911
callq *0x1848af(%rip)         # 0x5931c0
leaq 0x1c0(%rbx), %rdi
movq %r13, %rsi
callq 0x43057f
testq %rax, %rax
je 0x40e933
movl $0x206a5, %edi          # imm = 0x206A5
callq 0x403dfd
movl %eax, %esi
jmp 0x40e949
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x432e57
xorl %esi, %esi
movq %rbx, %rdi
callq 0x4097e6
movl %eax, %ebp
testl %eax, %eax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x40e968
movq %r15, %rdi
callq *%r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40e977
callq *0x184859(%rip)         # 0x5931d0
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_O2/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:
pushq %rbx
testl %esi, %esi
js 0x40f275
cmpl %esi, (%rdi)
jle 0x40f275
movl %esi, %eax
imulq $0xc, %rax, %rax
movq 0x8(%rdi), %rcx
movq 0x60(%rdi), %rdx
movslq 0x8(%rcx,%rax), %rax
movq 0x20(%rdx), %rcx
shlq $0x6, %rax
movq (%rcx,%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x12b947(%rip), %rbx    # 0x53aba0
testq %rsi, %rsi
je 0x40f277
movq 0x68(%rdi), %rdi
movq 0x18(%rax), %rdx
callq 0x40f27c
testq %rax, %rax
je 0x40f277
movq (%rax), %rbx
jmp 0x40f277
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x41039a
callq *0x182e40(%rip)         # 0x5931c0
movq 0x18(%r14), %rdi
movq %rbx, 0x38(%r14)
testq %rdi, %rdi
je 0x41039e
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x182e36(%rip)         # 0x5931d0
movq %rbx, 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x41051e
callq *0x182ca8(%rip)         # 0x5931c0
movq 0x18(%rbx), %rdi
jmp 0x410520
xorl %edi, %edi
movq %r15, 0x220(%rbx)
movq %r14, 0x228(%rbx)
andl $0x0, 0x230(%rbx)
movb $0x0, 0x234(%rbx)
andl $0x0, 0x280(%rbx)
testq %rdi, %rdi
je 0x41054e
callq *0x182c82(%rip)         # 0x5931d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x410d9f
callq *0x182427(%rip)         # 0x5931c0
movq 0x18(%r14), %rdi
jmp 0x410da1
xorl %edi, %edi
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 0x410dce
callq *0x182402(%rip)         # 0x5931d0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x18(%rdi), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x410e08
callq *0x1823be(%rip)         # 0x5931c0
movq 0x18(%r15), %rdi
jmp 0x410e0a
xorl %edi, %edi
testl %ebp, %ebp
cmoveq %r12, %r14
testq %r14, %r14
cmovel %r12d, %ebp
movb %bpl, 0x68(%r15)
movq %r14, 0xd8(%r15)
movq %rbx, 0xe0(%r15)
testq %rdi, %rdi
je 0x410e34
callq *0x18239c(%rip)         # 0x5931d0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x410f13
callq *0x1822b3(%rip)         # 0x5931c0
movq 0x18(%r14), %rdi
jmp 0x410f15
xorl %edi, %edi
movq 0x118(%r14), %r12
movq %r15, 0x120(%r14)
movq %rbx, 0x118(%r14)
testq %rdi, %rdi
je 0x410f35
callq *0x18229b(%rip)         # 0x5931d0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3OomClear
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 0x4113d8
cmpl $0x0, 0xc4(%rdi)
je 0x4113d9
retq
movb $0x0, 0x61(%rdi)
movl $0x0, 0x158(%rdi)
decl 0x160(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
xorl %ebp, %ebp
cmpl 0x28(%r14), %ebp
jge 0x41216f
xorl %r15d, %r15d
cmpl $0x2, %ebp
setb %r15b
xorl %ebp, %r15d
movq 0x20(%r14), %r13
testq %rbx, %rbx
je 0x412151
movq %r15, %rax
shlq $0x5, %rax
movq (%r13,%rax), %rsi
movq %rbx, %rdi
callq 0x406caf
testl %eax, %eax
jne 0x41216b
shlq $0x5, %r15
movq 0x18(%r13,%r15), %rdi
addq $0x8, %rdi
movq %r12, %rsi
callq 0x43057f
testq %rax, %rax
jne 0x4121a3
incl %ebp
jmp 0x41211d
movq %r12, %rdi
leaq 0x12d0a3(%rip), %rsi    # 0x53f21c
callq 0x406caf
testl %eax, %eax
jne 0x4121a1
movq 0x20(%r14), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x406c99
leaq 0x12d187(%rip), %r12    # 0x53f320
testl %eax, %eax
je 0x41211b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x412fd1
cmpq %rsi, 0x188(%rdi)
ja 0x413041
cmpq %rsi, 0x190(%rdi)
jbe 0x413041
movzwl 0x164(%rdi), %eax
cmpq %rdx, %rax
jb 0x413041
movq %rsi, %rax
retq
movq %rdx, %rsi
jmp 0x412fd6
// File: /workspace/github_c_makefile_star2_O2/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 0x413058
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rsi, 0x188(%rdi)
ja 0x4130a2
cmpq %r15, 0x190(%rbx)
jbe 0x4130a2
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x412fd6
testq %rax, %rax
je 0x41304c
movq %rax, %r14
movzwl 0x164(%rbx), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x401048
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4043ed
jmp 0x41304f
movq %r15, %rdi
movq %rdx, %rsi
callq 0x404e52
movq %rax, %r14
testq %rax, %rax
jne 0x41304f
movq %rbx, %rdi
callq 0x40a1fe
jmp 0x41304c
// File: /workspace/github_c_makefile_star2_O2/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 0x183718(%rip), %rdi    # 0x597a48
testq %rdi, %rdi
je 0x41434e
callq *0x17ee85(%rip)         # 0x5931c0
movq 0x183706(%rip), %rdi    # 0x597a48
testq %rdi, %rdi
je 0x41434e
popq %rax
jmpq *0x17ee82(%rip)         # 0x5931d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
pushq $0x8
popq %r14
xorl %r15d, %r15d
movslq 0x28(%rbx), %rcx
cmpq %rcx, %r15
jge 0x414fa7
movq 0x20(%rbx), %rcx
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0x414f9e
cmpb $0x0, 0x11(%rdi)
je 0x414f9e
callq 0x4083c8
xorl %eax, %eax
incq %r15
addq $0x20, %r14
jmp 0x414f7b
movb %al, 0x69(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %r14
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0x414fe3
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x414fda
callq 0x4092a1
incq %r15
addq $0x20, %r14
jmp 0x414fbf
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r15
cmpl %esi, 0x28(%rdi)
jg 0x41832a
leaq 0x1(%r15), %r13
leal (,%r13,8), %eax
movq 0x30(%r14), %rdi
movslq %eax, %rsi
callq 0x404e52
testq %rax, %rax
je 0x4183a7
movq %rax, %r12
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)
cmpb $0x2, 0x3f(%r14)
jne 0x418359
movl $0x8000, %edi           # imm = 0x8000
callq 0x407d85
movq 0x30(%r14), %rcx
movslq %ebp, %r15
movq %rax, (%rcx,%r15,8)
movq 0x30(%r14), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%r15,8)
pushq $0x7
popq %rax
cmovnel %ecx, %eax
jmp 0x41838d
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 0x41838d
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)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x7
popq %rax
xorl %ecx, %ecx
jmp 0x418395
// File: /workspace/github_c_makefile_star2_O2/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
cmpb $0x0, 0x55(%rdi)
je 0x41d22d
movq %rbx, %rdi
callq 0x41d279
movq %rax, 0x48(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x41d288
movl %eax, %edi
movq %rdi, 0x48(%rbx)
callq 0x404b49
testq %rax, %rax
je 0x41d26e
movq %rax, %r14
movl 0x48(%rbx), %edx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x41d296
testl %eax, %eax
je 0x41d273
movl %eax, %r15d
movq %r14, %rdi
callq 0x404c6c
movl %r15d, %ebp
jmp 0x41d220
pushq $0x7
popq %rbp
jmp 0x41d220
movq %r14, 0x18(%rbx)
jmp 0x41d220
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %r14
cmovgel %esi, %r14d
movl 0x20(%rdi), %eax
testl %eax, %eax
setle %cl
testl %edx, %edx
sete %dl
orb %cl, %dl
jne 0x4200b8
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
cmpq %rax, %rsi
jne 0x4200c0
movq 0x28(%rbx), %rdi
movl %r14d, %edx
callq 0x420153
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movb $0x1, %bpl
jmp 0x4200e2
testl %eax, %eax
jle 0x4200cc
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x412f53
movq 0x28(%rbx), %rdi
movl %r14d, %esi
callq 0x40d878
movq %rax, 0x18(%rbx)
testl %ebp, %ebp
sete %bpl
testq %rax, %rax
je 0x42013a
movq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x40654b
movl %eax, 0x20(%rbx)
testb %bpl, %bpl
jne 0x420111
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x420111
movq 0x18(%rbx), %rdi
movslq 0xc(%rbx), %rdx
callq 0x401048
movl 0x8(%rbx), %eax
btl $0xa, %eax
jae 0x420125
movq 0x10(%rbx), %rdi
callq *0x30(%rbx)
movzwl 0x8(%rbx), %eax
movq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rbx)
andl $0xe3ff, %eax           # imm = 0xE3FF
movw %ax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x42014e
movq %rbx, %rdi
callq 0x409f93
andq $0x0, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
pushq $0x7
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x40d878
testq %rax, %rax
je 0x4296f6
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq %rbx, (%rax)
movzwl 0x6(%rbx), %ecx
incl %ecx
movw %cx, 0x10(%rax)
popq %rbx
retq