LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
je 0x40430d
movq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rcx
incq %rcx
cmpq %rcx, %rsi
jae 0x40433a
leaq (%rsi,%rsi), %rcx
movq %rcx, 0x8(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x4a7a20
movsd 0x8(%rsp), %xmm0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x40433a
callq 0x402214
movq $0xf4240, 0x8(%rbx)     # imm = 0xF4240
movl $0x8, %edi
movl $0xf4240, %esi          # imm = 0xF4240
movsd %xmm0, 0x8(%rsp)
callq 0x4a87e0
movsd 0x8(%rsp), %xmm0
movq %rax, (%rbx)
movl $0x0, 0x10(%rbx)
movslq 0x10(%rbx), %rcx
movsd %xmm0, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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)
je 0x4043f8
movl 0x10(%rbx), %ebp
movl $0x400, %r15d           # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x4a7390
movq %rax, %r14
movb $0x0, (%rax)
testl %ebp, %ebp
jle 0x404429
xorl %r12d, %r12d
movq %rsp, %r13
movq (%rbx), %rax
movsd (%rax,%r12,8), %xmm0
movl $0xc8, %esi
movq %r13, %rdi
leaq 0x14667c(%rip), %rdx    # 0x54aa28
movb $0x1, %al
callq 0x4869f0
movq %r14, %rdi
callq 0x401100
movq %rax, %rbp
movq %r13, %rdi
callq 0x401100
addq %rbp, %rax
cmpq %rax, %r15
jae 0x4043df
addq %r15, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a7a20
movq %rax, %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x401068
incq %r12
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jl 0x404394
jmp 0x404429
movq $0xf4240, 0x8(%rbx)     # imm = 0xF4240
movl $0x8, %edi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x4a87e0
movq %rax, (%rbx)
movl $0x0, 0x10(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x4a7390
movq %rax, %r14
movb $0x0, (%rax)
movq %r14, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x404473
movq $0xf4240, 0x8(%rbx)     # imm = 0xF4240
movl $0x8, %edi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x4a87e0
movq %rax, (%rbx)
movl $0x0, 0x10(%rbx)
leaq 0x146d51(%rip), %rdi    # 0x54b1cb
movl $0x9, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x495520
cmpl $0x0, 0x10(%rbx)
jle 0x4044c1
xorl %r15d, %r15d
leaq 0x146d39(%rip), %r12    # 0x54b1d5
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
movb $0x1, %al
callq 0x486930
incq %r15
movslq 0x10(%rbx), %rax
cmpq %rax, %r15
jl 0x40449c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3_status
SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
  sqlite3_int64 iCur = 0, iHwtr = 0;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
  if( rc==0 ){
    *pCurrent = (int)iCur;
    *pHighwater = (int)iHwtr;
  }
  return rc;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
xorl %eax, %eax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
callq 0x4044d0
testl %eax, %eax
jne 0x4045ca
movl 0x10(%rsp), %ecx
movl %ecx, (%r14)
movl 0x8(%rsp), %ecx
movl %ecx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x178(%rdi), %rdx
xorl %eax, %eax
movl $0x0, %ecx
testq %rdx, %rdx
je 0x404a1c
xorl %ecx, %ecx
movq (%rdx), %rdx
incl %ecx
testq %rdx, %rdx
jne 0x404a12
movq 0x180(%rdi), %rdx
testq %rdx, %rdx
je 0x404a34
xorl %eax, %eax
movq (%rdx), %rdx
decl %eax
testq %rdx, %rdx
jne 0x404a2a
testq %rsi, %rsi
je 0x404a43
movl 0x168(%rdi), %edx
subl %ecx, %edx
movl %edx, (%rsi)
subl %ecx, %eax
addl 0x168(%rdi), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4232d8
movq 0x110(%r14), %r15
testq %r15, %r15
je 0x404b42
movq 0x28(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x423367
movq %rbx, %rdi
movq %r15, %rsi
callq 0x415f0a
movq %r12, %r15
testq %r12, %r12
jne 0x404b1c
cmpl $0x16bceaa5, 0x24(%r14) # imm = 0x16BCEAA5
je 0x404b85
movq 0xa0(%r14), %rdi
movswl 0x20(%r14), %esi
callq 0x4232d8
movq 0xa8(%r14), %rsi
testq %rsi, %rsi
je 0x404b71
movq %rbx, %rdi
callq 0x415f0a
movq 0xf0(%r14), %rsi
testq %rsi, %rsi
je 0x404b85
movq %rbx, %rdi
callq 0x415f0a
movq 0x68(%r14), %rsi
movl 0xb8(%r14), %edx
movq %rbx, %rdi
callq 0x423367
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x404bac
movq %rbx, %rdi
callq 0x415f0a
movq 0xe8(%r14), %rsi
testq %rsi, %rsi
je 0x404bcb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x415f0a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x40514e
callq 0x404c6d
jmp 0x405153
callq 0x405164
testl %eax, %eax
je 0x40515b
xorl %eax, %eax
popq %rbx
retq
movl %ebx, %edi
popq %rbx
jmpq *0x19b04c(%rip)         # 0x5a01b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1449f3(%rip), %rax    # 0x54c3b0
movzbl (%rsi), %ecx
movb (%rcx,%rax), %dl
movb (%r8,%rax), %cl
testq %r8, %r8
je 0x4079f3
cmpb %dl, %cl
jne 0x4079f3
movl $0x1, %r8d
movzbl (%rdi,%r8), %r9d
movb (%r9,%rax), %cl
movzbl (%rsi,%r8), %edx
movb (%rdx,%rax), %dl
testq %r9, %r9
je 0x4079f3
incq %r8
cmpb %dl, %cl
je 0x4079d6
movzbl %dl, %edx
movzbl %cl, %eax
subl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x409eee
movq %rbx, %rdi
callq 0x4182ff
movl 0x28(%rbx), %eax
testl %eax, %eax
jle 0x409f22
movl $0x18, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rcx
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0x409f13
callq 0x430ac4
movl 0x28(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x409efe
andb $-0xa, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x43b224
cmpb $0x0, 0x69(%rbx)
jne 0x409f3c
movq %rbx, %rdi
callq 0x418357
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x43b274
// File: /workspace/github_c_makefile_star2_O3/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 0x40a20c
movq %rsi, %rdx
movl $0x15, %esi
callq *0x50(%rax)
cmpl $0xc, %eax
je 0x40a20c
testl %eax, %eax
jne 0x40a214
xorl %eax, %eax
cmpb $0x0, 0xb(%rbx)
je 0x40a216
popq %rbx
retq
movzbl 0xe(%rbx), %esi
testl %esi, %esi
je 0x40a214
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 0x4234c6
movq (%r15), %rax
subq 0xb0(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
movq %rdx, (%rsp)
movq 0xe8(%r14), %rax
testq %rax, %rax
je 0x40ab85
movq 0xf0(%r14), %rdi
movq 0xe8(%rbx), %rsi
callq *%rax
testb $0x2, 0x68(%r14)
je 0x40aba5
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_O3/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 0x424ff7
movl $0x7, %ebp
testl %eax, %eax
jne 0x40ae6f
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_O3/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 0x40aedf
testb $0x4, %al
jne 0x40aee4
testb $0x12, %al
jne 0x4258d8
xorps %xmm0, %xmm0
retq
movsd (%rdi), %xmm0
retq
cvtsi2sdq (%rdi), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x40d558
callq *0x192c8b(%rip)         # 0x5a01c0
movq 0x18(%rbx), %rdi
addq $0x8, %rbx
leaq 0x10(%r14), %rax
testq %r14, %r14
cmoveq %rbx, %rax
movq (%rax), %rbx
testq %rdi, %rdi
je 0x40d56a
callq *0x192c7a(%rip)         # 0x5a01d0
jmp 0x40d56a
addq $0x8, %rbx
leaq 0x10(%r14), %rax
testq %r14, %r14
cmoveq %rbx, %rax
movq (%rax), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x40d65c
movq %rdi, %rbx
movq 0xe8(%rdi), %r14
testq %r14, %r14
je 0x40d65c
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x40d63a
callq *0x192b86(%rip)         # 0x5a01c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40d66a
movq %rax, %r14
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x40d65f
callq *0x192b76(%rip)         # 0x5a01d0
jmp 0x40d65f
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x425909
testl %eax, %eax
je 0x40dbc1
movq %rsp, %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x425e39
testl %eax, %eax
je 0x40dbab
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl 0x8(%rbx), %eax
orl $0x8, %eax
movw %ax, 0x8(%rbx)
testl %ebp, %ebp
je 0x40dbb8
movq %rbx, %rdi
callq 0x42eb3a
movzwl 0x8(%rbx), %eax
jmp 0x40dbb8
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_O3/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 0x40ec5e
movq %r14, %rdi
callq 0x415f0a
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x40ec6f
movq %r14, %rdi
callq 0x4385eb
testq %r14, %r14
je 0x40ec7f
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_O3/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 0x40f91c
movq %rdi, %rbx
movl 0x70(%rdi), %eax
cmpl $0xa029a697, %eax       # imm = 0xA029A697
je 0x40f8fe
cmpl $0xf03b7906, %eax       # imm = 0xF03B7906
je 0x40f8fe
cmpl $0x4b771290, %eax       # imm = 0x4B771290
jne 0x40f94f
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40f90d
callq *0x1908b3(%rip)         # 0x5a01c0
cmpb $0x0, 0x61(%rbx)
je 0x40f925
leaq 0x141a70(%rip), %r14    # 0x55138a
jmp 0x40f93e
leaq 0x141a67(%rip), %r14    # 0x55138a
jmp 0x40f996
movq 0x150(%rbx), %rdi
movl $0x1, %esi
callq 0x40af5d
movq %rax, %r14
testq %rax, %rax
je 0x40f9a1
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x40f996
callq *0x190883(%rip)         # 0x5a01d0
jmp 0x40f996
leaq 0x14263b(%rip), %rsi    # 0x551f91
leaq 0x14c147(%rip), %rdx    # 0x55baa4
movl $0x15, %edi
xorl %eax, %eax
callq 0x40765d
leaq 0x140fbf(%rip), %rsi    # 0x55092f
leaq 0x14535d(%rip), %rdx    # 0x554cd4
leaq 0x140de8(%rip), %r8     # 0x550766
movl $0x15, %edi
movl $0x25a2f, %ecx          # imm = 0x25A2F
xorl %eax, %eax
callq 0x40765d
leaq 0x145323(%rip), %r14    # 0x554cb9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x50(%rbx), %eax
cmpq $0x204, %rax            # imm = 0x204
je 0x40f9ce
cmpl $0x65, %eax
je 0x40f9c2
cmpl $0x64, %eax
jne 0x40f9da
leaq 0x1453ad(%rip), %r14    # 0x554d6a
jmp 0x40f93e
leaq 0x1453b7(%rip), %r14    # 0x554d80
jmp 0x40f93e
leaq 0x14537f(%rip), %r14    # 0x554d54
jmp 0x40f93e
movzbl %al, %eax
leaq 0x145362(%rip), %r14    # 0x554d46
cmpl $0x1c, %eax
ja 0x40f93e
movl $0x1410004, %ecx        # imm = 0x1410004
btq %rax, %rcx
jb 0x40f93e
leaq 0x18ee6d(%rip), %rcx    # 0x59e870
movq (%rcx,%rax,8), %r14
jmp 0x40f93e
// File: /workspace/github_c_makefile_star2_O3/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 0x40ff2b
callq *0x190295(%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 0x40ff51
callq *0x19027f(%rip)         # 0x5a01d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x410d23
callq *0x18f49d(%rip)         # 0x5a01c0
leaq 0x1c0(%r14), %rdi
xorl %r12d, %r12d
movq %rbp, %rsi
xorl %edx, %edx
callq 0x437afd
cmpq $0x0, 0x10(%rax)
je 0x410d6c
leaq 0x13fbea(%rip), %rsi    # 0x55092f
leaq 0x143f88(%rip), %rdx    # 0x554cd4
leaq 0x13fa13(%rip), %r8     # 0x550766
movl $0x15, %r12d
movl $0x15, %edi
movl $0x206a5, %ecx          # imm = 0x206A5
xorl %eax, %eax
callq 0x40765d
jmp 0x410d80
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x43ab0c
cmpb $0x0, 0x61(%r14)
je 0x410d97
movq %r14, %rdi
callq 0x423568
movl $0x7, %r12d
jmp 0x410d9b
andl 0x54(%r14), %r12d
testl %r12d, %r12d
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x410db0
movq %r15, %rdi
callq *%rbx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x410dbf
callq *0x18f411(%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_O3/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 0x4117a0
cmpl %esi, (%rdi)
jle 0x4117a0
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
leaq 0x13b41c(%rip), %rbx    # 0x54cba0
testq %rsi, %rsi
je 0x4117a2
movq 0x68(%rdi), %rdi
movq 0x18(%rax), %rdx
callq 0x4117a7
testq %rax, %rax
je 0x4117a2
movq (%rax), %rbx
jmp 0x4117a2
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x412b37
callq *0x18d6a3(%rip)         # 0x5a01c0
movq 0x18(%r14), %rdi
movq %rbx, 0x38(%r14)
testq %rdi, %rdi
je 0x412b3b
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18d699(%rip)         # 0x5a01d0
movq %rbx, 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x412d57
callq *0x18d49d(%rip)         # 0x5a01c0
movq 0x18(%rbx), %rdi
movq %r15, 0x220(%rbx)
movq %r14, 0x228(%rbx)
xorl %eax, %eax
movl %eax, 0x230(%rbx)
movb $0x0, 0x234(%rbx)
movl %eax, 0x280(%rbx)
testq %rdi, %rdi
je 0x412d7a
callq *0x18d47b(%rip)         # 0x5a01d0
jmp 0x412d7a
movq %r15, 0x220(%rbx)
movq %r14, 0x228(%rbx)
xorl %eax, %eax
movl %eax, 0x230(%rbx)
movb $0x0, 0x234(%rbx)
movl %eax, 0x280(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x41373f
callq *0x18ca87(%rip)         # 0x5a01c0
movq 0x18(%r14), %rdi
jmp 0x413741
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 0x41376e
callq *0x18ca62(%rip)         # 0x5a01d0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4137a8
callq *0x18ca1e(%rip)         # 0x5a01c0
movq 0x18(%r15), %rdi
jmp 0x4137aa
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 0x4137d4
callq *0x18c9fc(%rip)         # 0x5a01d0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x4138f9
callq *0x18c8ed(%rip)         # 0x5a01c0
movq 0x18(%r15), %rdi
movq 0x118(%r15), %rbx
movq %r12, 0x120(%r15)
movq %r14, 0x118(%r15)
testq %rdi, %rdi
je 0x41390e
callq *0x18c8d9(%rip)         # 0x5a01d0
jmp 0x41390e
movq 0x118(%r15), %rbx
movq %r12, 0x120(%r15)
movq %r14, 0x118(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, (%rsp)
movl 0x28(%rdi), %ebp
testl %ebp, %ebp
jle 0x414f6d
movq (%rsp), %rax
movq 0x20(%rax), %r13
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpl $0x2, %r15d
setb %r14b
xorl %r15d, %r14d
testq %rbx, %rbx
je 0x414f45
movq %r14, %rax
shlq $0x5, %rax
movq (%r13,%rax), %rsi
movq %rbx, %rdi
callq 0x4079b2
testl %eax, %eax
jne 0x414f65
shlq $0x5, %r14
movq 0x18(%r13,%r14), %rdi
addq $0x8, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x437afd
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x414fbb
incl %r15d
cmpl %r15d, %ebp
jne 0x414f1a
movq %r12, %rdi
leaq 0x13c31d(%rip), %rsi    # 0x551294
callq 0x4079b2
testl %eax, %eax
jne 0x414fb9
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rsi
testq %rbx, %rbx
je 0x414fa0
testq %rsi, %rsi
je 0x414fb9
movq %rbx, %rdi
callq 0x4079b2
jmp 0x414faa
negq %rsi
movl $0x0, %eax
sbbl %eax, %eax
leaq 0x13c3e7(%rip), %r12    # 0x551398
testl %eax, %eax
je 0x414f0b
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_O3/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 0x415fac
cmpq %rsi, 0x188(%rdi)
ja 0x41601c
cmpq %rsi, 0x190(%rdi)
jbe 0x41601c
movzwl 0x164(%rdi), %eax
cmpq %rdx, %rax
jb 0x41601c
movq %rsi, %rax
retq
movq %rdx, %rsi
jmp 0x415fb1
// File: /workspace/github_c_makefile_star2_O3/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 0x416033
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 0x416085
cmpq %r15, 0x190(%rbx)
jbe 0x416085
movq %rbx, %rdi
movq %r14, %rsi
callq 0x415fb1
testq %rax, %rax
je 0x416027
movq %rax, %r14
movzwl 0x164(%rbx), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x401048
testq %r15, %r15
je 0x41602a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x415f0a
jmp 0x41602a
callq 0x404c6d
testl %eax, %eax
je 0x4160bc
cmpb $0x0, 0x61(%rbx)
jne 0x416027
cmpb $0x0, 0x62(%rbx)
jne 0x416027
movb $0x1, 0x61(%rbx)
cmpl $0x0, 0xc4(%rbx)
jle 0x4160b1
movl $0x1, 0x158(%rbx)
incl 0x160(%rbx)
jmp 0x416027
movq %r15, %rdi
movq %r14, %rsi
callq 0x405592
movq %rax, %r14
testq %rax, %rax
jne 0x41602a
jmp 0x41608e
// File: /workspace/github_c_makefile_star2_O3/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 0x18d384(%rip), %rdi    # 0x5a4a48
testq %rdi, %rdi
je 0x4176e2
callq *0x188af1(%rip)         # 0x5a01c0
movq 0x18d372(%rip), %rdi    # 0x5a4a48
testq %rdi, %rdi
je 0x4176e2
popq %rax
jmpq *0x188aee(%rip)         # 0x5a01d0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x28(%rdi), %eax
movb $0x1, %cl
testl %eax, %eax
jle 0x41834e
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rdx
movq (%rdx,%r14), %rdi
testq %rdi, %rdi
je 0x41833f
cmpb $0x0, 0x11(%rdi)
je 0x41833f
incl 0x14(%rdi)
cmpb $0x0, 0x12(%rdi)
jne 0x41833d
callq 0x420275
movl 0x28(%rbx), %eax
xorl %ecx, %ecx
incq %r15
movslq %eax, %rdx
addq $0x20, %r14
cmpq %rdx, %r15
jl 0x418319
movb %cl, 0x69(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x28(%rdi), %eax
testl %eax, %eax
jle 0x4183a3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rcx
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0x41838f
cmpb $0x0, 0x11(%rdi)
je 0x41838f
decl 0x14(%rdi)
jne 0x41838f
callq 0x4202fb
movl 0x28(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x41836f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpl %esi, 0x28(%rdi)
jle 0x41bf33
cmpb $0x2, 0x3f(%r14)
jne 0x41bf4a
movl $0x8000, %edi           # imm = 0x8000
callq 0x4053ac
movq %rax, %r15
testq %rax, %rax
je 0x41bf11
movl $0x8000, %edx           # imm = 0x8000
movq %r15, %rdi
xorl %esi, %esi
callq 0x4010b8
movq 0x30(%r14), %rax
movslq %ebp, %r12
movq %r15, (%rax,%r12,8)
movq 0x30(%r14), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%r12,8)
movl $0x7, %r15d
cmovnel %ecx, %r15d
jmp 0x41bf87
movq 0x30(%r14), %r12
callq 0x404c6d
movl $0x7, %r15d
testl %eax, %eax
je 0x41bfa4
xorl %eax, %eax
jmp 0x41bf8f
movq 0x8(%r14), %rdi
movzbl 0x40(%r14), %ecx
movslq %ebp, %r12
leaq (,%r12,8), %r8
addq 0x30(%r14), %r8
movq (%rdi), %rax
movl %ebp, %esi
movl $0x8000, %edx           # imm = 0x8000
callq *0x68(%rax)
movl %eax, %r15d
cmpb $0x8, %r15b
jne 0x41bf87
orb $0x2, 0x42(%r14)
xorl %eax, %eax
cmpl $0x8, %r15d
cmovel %eax, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r12,8), %rax
movq %rax, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %r13
incq %r13
leal (,%r13,8), %eax
movslq %eax, %rsi
movq %r12, %rdi
callq 0x405592
testq %rax, %rax
je 0x41bf46
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)
jmp 0x41bee9
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: releasePageOne
SQLITE_PRIVATE void sqlite3PagerUnrefPageOne(DbPage *pPg){
  Pager *pPager;
  assert( pPg!=0 );
  assert( pPg->pgno==1 );
  assert( (pPg->flags & PGHDR_MMAP)==0 ); /* Page1 is never memory mapped */
  pPager = pPg->pPager;
  sqlite3PagerResetLockTimeout(pPager);
  sqlite3PcacheRelease(pPg);
  pagerUnlockIfUnused(pPager);
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
callq 0x41e503
movq 0x118(%rbx), %rax
cmpl $0x0, 0x18(%rax)
je 0x420a09
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x41cd3e
// File: /workspace/github_c_makefile_star2_O3/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 0x421b2d
testb %bpl, %bpl
je 0x421ae3
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 0x4053ac
testq %rax, %rax
je 0x421b20
movq %rax, %r14
movl 0x48(%rbx), %edx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x421b73
testl %eax, %eax
je 0x421b27
movl %eax, %r15d
movq %r14, %rdi
callq 0x4054f6
movl %r15d, %ebp
jmp 0x421ad6
movl $0x7, %ebp
jmp 0x421ad6
movq %r14, 0x18(%rbx)
jmp 0x421ad6
// File: /workspace/github_c_makefile_star2_O3/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 0x42358b
cmpl $0x0, 0xc4(%rdi)
jne 0x42358b
movb $0x0, 0x61(%rdi)
movl $0x0, 0x158(%rdi)
decl 0x160(%rdi)
movl $0x7, 0x50(%rdi)
movl $0x7, %esi
jmp 0x418423
// File: /workspace/github_c_makefile_star2_O3/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 0x425044
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
cmpq %rax, %rsi
jne 0x42504c
movq 0x28(%rbx), %rdi
movl %r14d, %edx
callq 0x425125
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movb $0x1, %bpl
jmp 0x42507d
testl %eax, %eax
jle 0x425058
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x415f0a
movq 0x28(%rbx), %rdi
movl %r14d, %esi
testq %rdi, %rdi
je 0x42506b
callq 0x415fb1
jmp 0x425073
movq %rsi, %rdi
callq 0x4053ac
movq %rax, 0x18(%rbx)
testl %ebp, %ebp
sete %bpl
testq %rax, %rax
je 0x4250f6
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x4250a6
cmpq %rax, 0x188(%rcx)
ja 0x4250a6
cmpq %rax, 0x190(%rcx)
jbe 0x4250a6
movzwl 0x164(%rcx), %eax
jmp 0x4250af
movq %rax, %rdi
callq *0x17b0c9(%rip)         # 0x5a0178
movl %eax, 0x20(%rbx)
testb %bpl, %bpl
jne 0x4250cd
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x4250cd
movq 0x18(%rbx), %rdi
movslq 0xc(%rbx), %rdx
callq 0x401048
movl 0x8(%rbx), %eax
btl $0xa, %eax
jae 0x4250e1
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 0x425120
testb $0x24, 0x9(%rbx)
je 0x425106
movq %rbx, %rdi
callq 0x424f3d
jmp 0x42510c
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_O3/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 0x42fce7
callq 0x415fb1
jmp 0x42fcef
movq %rsi, %rdi
callq 0x4053ac
testq %rax, %rax
je 0x42fd09
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
movq %rbx, (%rax)
movzwl 0x6(%rbx), %ecx
incl %ecx
movw %cx, 0x10(%rax)
popq %rbx
retq