LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeSchema
SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
  BtShared *pBt = p->pBt;
  sqlite3BtreeEnter(p);
  if( !pBt->pSchema && nBytes ){
    pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
    pBt->xFreeSchema = xFree;
  }
  sqlite3BtreeLeave(p);
  return pBt->pSchema;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r12
callq 0xd284
testl %ebp, %ebp
je 0x1be47
cmpq $0x0, 0x40(%r12)
jne 0x1be47
movl %ebp, %edi
callq 0xa35e
movq %rax, %r15
testq %rax, %rax
je 0x1be3d
movslq %ebp, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x7180
movq %r15, 0x40(%r12)
movq %r14, 0x48(%r12)
cmpb $0x0, 0x11(%rbx)
je 0x1be69
decl 0x14(%rbx)
jne 0x1be69
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x1be65
callq *0x6d4c3(%rip)          # 0x89328
movb $0x0, 0x12(%rbx)
movq 0x40(%r12), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: vdbeFreeOpArray
static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
  if( aOp ){
    Op *pOp;
    for(pOp=aOp; pOp<&aOp[nOp]; pOp++){
      freeP4(db, pOp->p4type, pOp->p4.p);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
      sqlite3DbFree(db, pOp->zComment);
#endif     
    }
  }
  sqlite3DbFree(db, aOp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x24745
testl %edx, %edx
jle 0x24745
movslq %edx, %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,8), %r15
movq %rbx, %r12
movsbl 0x1(%r12), %esi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x2475b
addq $0x18, %r12
cmpq %r15, %r12
jb 0x24729
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9b58
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeEnter
SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
  int i;
  yDbMask mask;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  if( p->lockMask==0 ) return;  /* The common case */
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;
  for(i=0, mask=1; i<nDb; i++, mask += mask){
    if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
      sqlite3BtreeEnter(aDb[i].pBt);
    }
  }
}

// Assembly:
cmpl $0x0, 0xa4(%rdi)
je 0x24e07
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x28(%rax), %r14
testq %r14, %r14
jle 0x24dff
movq 0x20(%rax), %r15
shlq $0x5, %r14
movl $0x1, %ebp
xorl %r12d, %r12d
cmpq $0x20, %r12
je 0x24df4
testl %ebp, 0xa4(%rbx)
je 0x24df4
movq 0x8(%r15,%r12), %rdi
testq %rdi, %rdi
je 0x24df4
callq 0xd284
addl %ebp, %ebp
addq $0x20, %r12
cmpq %r12, %r14
jne 0x24dd7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeCheckFk
SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
  sqlite3 *db = p->db;
  if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0) 
   || (!deferred && p->nFkConstraint>0) 
  ){
    p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
    p->errorAction = OE_Abort;
    sqlite3SetString(&p->zErrMsg, db, "FOREIGN KEY constraint failed");
    return SQLITE_ERROR;
  }
  return SQLITE_OK;
}

// Assembly:
movl %esi, %eax
movq (%rdi), %rsi
testl %eax, %eax
je 0x24f9d
movq 0x310(%rsi), %rax
addq 0x308(%rsi), %rax
jle 0x24fa7
pushq %rax
movl $0x313, 0x94(%rdi)      # imm = 0x313
movb $0x2, 0x98(%rdi)
addq $0x58, %rdi
leaq 0x4b678(%rip), %rdx     # 0x70604
xorl %eax, %eax
callq 0x25d3b
movl $0x1, %eax
addq $0x8, %rsp
retq
cmpq $0x0, 0xd0(%rdi)
jg 0x24f6f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeLeave
SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){
  int i;
  yDbMask mask;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  if( p->lockMask==0 ) return;  /* The common case */
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;
  for(i=0, mask=1; i<nDb; i++, mask += mask){
    if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
      sqlite3BtreeLeave(aDb[i].pBt);
    }
  }
}

// Assembly:
cmpl $0x0, 0xa4(%rdi)
je 0x25037
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x28(%rax), %r14
testq %r14, %r14
jle 0x25029
movq 0x20(%rax), %r15
shlq $0x5, %r14
movl $0x1, %ebp
xorl %r12d, %r12d
cmpq $0x20, %r12
je 0x2501e
testl %ebp, 0xa4(%rbx)
je 0x2501e
movq 0x8(%r15,%r12), %r13
testq %r13, %r13
je 0x2501e
cmpb $0x0, 0x11(%r13)
je 0x2501e
decl 0x14(%r13)
jne 0x2501e
movq 0x8(%r13), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x25019
callq *0x6430f(%rip)          # 0x89328
movb $0x0, 0x12(%r13)
addl %ebp, %ebp
addq $0x20, %r12
cmpq %r12, %r14
jne 0x24fe1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeMemFromBtree
SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(
  BtCursor *pCur,   /* Cursor pointing at record to retrieve. */
  u32 offset,       /* Offset from the start of data to return bytes from. */
  u32 amt,          /* Number of bytes to return. */
  int key,          /* If true, retrieve from the btree key, not data. */
  Mem *pMem         /* OUT: Return data in this Mem structure. */
){
  char *zData;        /* Data from the btree layer */
  u32 available = 0;  /* Number of bytes available on the local btree page */
  int rc = SQLITE_OK; /* Return code */

  assert( sqlite3BtreeCursorIsValid(pCur) );

  /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert() 
  ** that both the BtShared and database handle mutexes are held. */
  assert( (pMem->flags & MEM_RowSet)==0 );
  if( key ){
    zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
  }else{
    zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
  }
  assert( zData!=0 );

  if( offset+amt<=available ){
    sqlite3VdbeMemRelease(pMem);
    pMem->z = &zData[offset];
    pMem->flags = MEM_Blob|MEM_Ephem;
  }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
    pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
    pMem->enc = 0;
    pMem->type = SQLITE_BLOB;
    if( key ){
      rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
    }else{
      rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
    }
    pMem->z[amt] = 0;
    pMem->z[amt+1] = 0;
    if( rc!=SQLITE_OK ){
      sqlite3VdbeMemRelease(pMem);
    }
  }
  pMem->n = (int)amt;

  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl $0x0, 0x4(%rsp)
cmpb $0x1, 0x77(%rdi)
jne 0x2d93f
xorl %edx, %edx
testl %ebp, %ebp
sete %dl
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
callq 0x315a6
movq %rax, %r13
jmp 0x2d942
xorl %r13d, %r13d
leal (%r14,%r15), %eax
cmpl 0x4(%rsp), %eax
jbe 0x2d980
leal 0x2(%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x105ee
testl %eax, %eax
jne 0x2d99a
movl $0x40610, 0x24(%rbx)    # imm = 0x40610
movq 0x8(%rbx), %rcx
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
testl %ebp, %ebp
je 0x2d9ad
xorl %r8d, %r8d
callq 0x22e51
jmp 0x2d9b2
movq %rbx, %rdi
callq 0xf0a0
movl %r15d, %eax
addq %rax, %r13
movq %r13, 0x8(%rbx)
movw $0x1010, 0x24(%rbx)     # imm = 0x1010
xorl %eax, %eax
movl %r14d, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1273d
movl %eax, %ebp
movq 0x8(%rbx), %rcx
movl %r14d, %edx
xorl %eax, %eax
movb %al, (%rcx,%rdx)
movq 0x8(%rbx), %rcx
leal 0x1(%r14), %edx
movb %al, (%rcx,%rdx)
testl %ebp, %ebp
je 0x2d99a
movq %rbx, %rdi
callq 0xf0a0
movl %ebp, %eax
jmp 0x2d99a
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeBeginStmt
SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree *p, int iStatement){
  int rc;
  BtShared *pBt = p->pBt;
  sqlite3BtreeEnter(p);
  assert( p->inTrans==TRANS_WRITE );
  assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
  assert( iStatement>0 );
  assert( iStatement>p->db->nSavepoint );
  assert( pBt->inTransaction==TRANS_WRITE );
  /* At the pager level, a statement transaction is a savepoint with
  ** an index greater than all savepoints created explicitly using
  ** SQL statements. It is illegal to open, release or rollback any
  ** such savepoints while the statement transaction savepoint is active.
  */
  rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
callq 0xd284
movq (%r14), %rdi
movl %ebp, %esi
callq 0x21481
movl %eax, %ebp
cmpb $0x0, 0x11(%rbx)
je 0x2dd1f
decl 0x14(%rbx)
jne 0x2dd1f
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x2dd1b
callq *0x5b60d(%rip)          # 0x89328
movb $0x0, 0x12(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeSorterCompare
SQLITE_PRIVATE int sqlite3VdbeSorterCompare(
  const VdbeCursor *pCsr,         /* Sorter cursor */
  Mem *pVal,                      /* Value to compare to current sorter key */
  int nIgnore,                    /* Ignore this many fields at the end */
  int *pRes                       /* OUT: Result of comparison */
){
  VdbeSorter *pSorter = pCsr->pSorter;
  void *pKey; int nKey;           /* Sorter key to compare pVal with */

  pKey = vdbeSorterRowkey(pSorter, &nKey);
  vdbeSorterCompare(pCsr, nIgnore, pVal->z, pVal->n, pKey, nKey, pRes);
  return SQLITE_OK;
}

// Assembly:
movq 0x50(%rdi), %rax
movq 0x30(%rax), %r8
testq %r8, %r8
je 0x2f4b1
movq 0x28(%rax), %rax
movslq 0x4(%r8), %r9
shlq $0x6, %r9
leaq (%rax,%r9), %r8
addq $0x14, %r8
addq %r9, %rax
addq $0x28, %rax
jmp 0x2f4b9
movq 0x40(%rax), %rax
leaq 0x8(%rax), %r8
pushq %rax
movl (%r8), %r9d
movq (%rax), %r8
movq 0x8(%rsi), %rax
movl 0x20(%rsi), %r10d
movq %rcx, (%rsp)
movl %edx, %esi
movq %rax, %rdx
movl %r10d, %ecx
callq 0x34262
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3AnalysisLoad
SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
  analysisInfo sInfo;
  HashElem *i;
  char *zSql;
  int rc;

  assert( iDb>=0 && iDb<db->nDb );
  assert( db->aDb[iDb].pBt!=0 );

  /* Clear any prior statistics */
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
    Index *pIdx = sqliteHashData(i);
    sqlite3DefaultRowEst(pIdx);
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
    sqlite3DeleteIndexSamples(db, pIdx);
    pIdx->aSample = 0;
#endif
  }

  /* Check to make sure the sqlite_stat1 table exists */
  sInfo.db = db;
  sInfo.zDatabase = db->aDb[iDb].zName;
  if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){
    return SQLITE_ERROR;
  }

  /* Load new statistics out of the sqlite_stat1 table */
  zSql = sqlite3MPrintf(db, 
      "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase);
  if( zSql==0 ){
    rc = SQLITE_NOMEM;
  }else{
    rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
    sqlite3DbFree(db, zSql);
  }


  /* Load the statistics from the sqlite_stat4 table. */
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  if( rc==SQLITE_OK ){
    int lookasideEnabled = db->lookaside.bEnabled;
    db->lookaside.bEnabled = 0;
    rc = loadStat4(db, sInfo.zDatabase);
    db->lookaside.bEnabled = lookasideEnabled;
  }
#endif

  if( rc==SQLITE_NOMEM ){
    db->mallocFailed = 1;
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movslq %esi, %r14
shlq $0x5, %r14
movq 0x18(%rax,%r14), %rax
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x2fdbd
movq 0x10(%r15), %rdi
callq 0x34f9f
movq (%r15), %r15
jmp 0x2fdaa
movq %rbx, 0x8(%rsp)
movq 0x20(%rbx), %rax
movq (%rax,%r14), %r14
movq %r14, 0x10(%rsp)
leaq 0x4104f(%rip), %rsi     # 0x70e25
movq %rbx, %rdi
movq %r14, %rdx
callq 0x34fe2
testq %rax, %rax
je 0x2fe2b
leaq 0x4101c(%rip), %rsi     # 0x70e09
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11ce7
testq %rax, %rax
je 0x2fe32
movq %rax, %r14
leaq 0x52e0(%rip), %rdx      # 0x350e9
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x12ccb
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b58
jmp 0x2fe37
movl $0x1, %ebp
jmp 0x2fe40
movl $0x7, %ebp
cmpl $0x7, %ebp
jne 0x2fe40
movb $0x1, 0x50(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeMaxPageCount
SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){
  int n;
  sqlite3BtreeEnter(p);
  n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
  sqlite3BtreeLeave(p);
  return n;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xd284
movq 0x8(%rbx), %rax
movq (%rax), %rcx
testl %ebp, %ebp
jle 0x310e9
movl %ebp, 0xc0(%rcx)
movl 0xc0(%rcx), %ebp
cmpb $0x0, 0x11(%rbx)
je 0x3110d
decl 0x14(%rbx)
jne 0x3110d
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x31109
callq *0x5821f(%rip)          # 0x89328
movb $0x0, 0x12(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: vdbeSorterCompare
static void vdbeSorterCompare(
  const VdbeCursor *pCsr,         /* Cursor object (for pKeyInfo) */
  int nIgnore,                    /* Ignore the last nIgnore fields */
  const void *pKey1, int nKey1,   /* Left side of comparison */
  const void *pKey2, int nKey2,   /* Right side of comparison */
  int *pRes                       /* OUT: Result of comparison */
){
  KeyInfo *pKeyInfo = pCsr->pKeyInfo;
  VdbeSorter *pSorter = pCsr->pSorter;
  UnpackedRecord *r2 = pSorter->pUnpacked;
  int i;

  if( pKey2 ){
    sqlite3VdbeRecordUnpack(pKeyInfo, nKey2, pKey2, r2);
  }

  if( nIgnore ){
    r2->nField = pKeyInfo->nField - nIgnore;
    assert( r2->nField>0 );
    for(i=0; i<r2->nField; i++){
      if( r2->aMem[i].flags & MEM_Null ){
        *pRes = -1;
        return;
      }
    }
    r2->flags |= UNPACKED_PREFIX_MATCH;
  }

  *pRes = sqlite3VdbeRecordCompare(nKey1, pKey1, r2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movl %esi, %r15d
movq 0x10(%rdi), %r12
movq 0x50(%rdi), %rax
movq 0x48(%rax), %r14
testq %r8, %r8
je 0x34297
movq %r12, %rdi
movl %r9d, %esi
movq %r8, %rdx
movq %r14, %rcx
callq 0x2eab8
movq 0x40(%rsp), %r13
testl %r15d, %r15d
je 0x342e0
movzwl 0x6(%r12), %eax
subw %r15w, %ax
movw %ax, 0x8(%r14)
je 0x342db
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movq 0x10(%r14), %rax
movzwl %cx, %ecx
imulq $0x38, %rcx, %rcx
xorl %edx, %edx
testb $0x1, 0x24(%rax,%rdx)
jne 0x34300
addq $0x38, %rdx
cmpq %rdx, %rcx
jne 0x342cb
orb $0x2, 0xa(%r14)
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31a67
movl %eax, (%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x342ed
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3DefaultRowEst
SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
  tRowcnt *a = pIdx->aiRowEst;
  int i;
  tRowcnt n;
  assert( a!=0 );
  a[0] = pIdx->pTable->nRowEst;
  if( a[0]<10 ) a[0] = 10;
  n = 10;
  for(i=1; i<=pIdx->nKeyCol; i++){
    a[i] = n;
    if( n>5 ) n--;
  }
  if( pIdx->onError!=OE_None ){
    a[pIdx->nKeyCol] = 1;
  }
}

// Assembly:
movq 0x18(%rdi), %rax
movl 0x38(%rax), %ecx
cmpl $0xb, %ecx
movl $0xa, %edx
cmovbl %edx, %ecx
movq 0x10(%rdi), %rax
movl %ecx, (%rax)
movzwl 0x5e(%rdi), %ecx
testq %rcx, %rcx
je 0x34fd4
xorl %esi, %esi
movl %edx, 0x4(%rax,%rsi,4)
cmpl $0x6, %edx
adcl $-0x1, %edx
incq %rsi
cmpq %rsi, %rcx
jne 0x34fc2
cmpb $0x0, 0x62(%rdi)
je 0x34fe1
movl $0x1, (%rax,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: analysisLoader
static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
  analysisInfo *pInfo = (analysisInfo*)pData;
  Index *pIndex;
  Table *pTable;
  const char *z;

  assert( argc==3 );
  UNUSED_PARAMETER2(NotUsed, argc);

  if( argv==0 || argv[0]==0 || argv[2]==0 ){
    return 0;
  }
  pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase);
  if( pTable==0 ){
    return 0;
  }
  if( argv[1]==0 ){
    pIndex = 0;
  }else if( sqlite3_stricmp(argv[0],argv[1])==0 ){
    pIndex = sqlite3PrimaryKeyIndex(pTable);
  }else{
    pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
  }
  z = argv[2];

  if( pIndex ){
    decodeIntArray((char*)z, pIndex->nKeyCol+1, pIndex->aiRowEst, pIndex);
    if( pIndex->pPartIdxWhere==0 ) pTable->nRowEst = pIndex->aiRowEst[0];
  }else{
    Index fakeIdx;
    fakeIdx.szIdxRow = pTable->szTabRow;
    decodeIntArray((char*)z, 1, &pTable->nRowEst, &fakeIdx);
    pTable->szTabRow = fakeIdx.szIdxRow;
  }

  return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x35227
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbp
movq (%rdx), %r13
testq %r13, %r13
je 0x35219
movq 0x10(%rbp), %r14
testq %r14, %r14
je 0x35219
movq (%rdi), %r12
movq 0x8(%rdi), %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x34fe2
testq %rax, %rax
je 0x35219
movq %rax, %rbx
movq 0x8(%rbp), %rsi
testq %rsi, %rsi
je 0x3517c
movb (%r13), %al
testb %al, %al
je 0x35181
incq %r13
leaq 0x38238(%rip), %rdx     # 0x6d390
movq %rsi, %rcx
movzbl %al, %edi
movb (%rdi,%rdx), %dil
movzbl (%rcx), %r8d
cmpb (%r8,%rdx), %dil
jne 0x35184
incq %rcx
movb (%r13), %al
incq %r13
testb %al, %al
jne 0x3515b
jmp 0x35184
xorl %r15d, %r15d
jmp 0x351c0
movq %rsi, %rcx
movzbl %al, %eax
leaq 0x38202(%rip), %rdx     # 0x6d390
movb (%rax,%rdx), %al
movzbl (%rcx), %ecx
cmpb (%rcx,%rdx), %al
jne 0x351b2
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x351c0
movb 0x63(%r15), %al
andb $0x3, %al
cmpb $0x2, %al
je 0x351c0
movq 0x28(%r15), %r15
jmp 0x3519d
movq %r12, %rdi
movq %r15, %rdx
callq 0x34cac
movq %rax, %r15
testq %r15, %r15
je 0x351ed
movzwl 0x5e(%r15), %esi
incl %esi
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x3522a
cmpq $0x0, 0x48(%r15)
jne 0x35219
movq 0x10(%r15), %rax
movl (%rax), %eax
movl %eax, 0x38(%rbx)
jmp 0x35219
movzwl 0x46(%rbx), %eax
movq %rsp, %r15
movw %ax, 0x5c(%r15)
movq %rbx, %rdx
addq $0x38, %rdx
movq %r14, %rdi
movl $0x1, %esi
movq %r15, %rcx
callq 0x3522a
movzwl 0x5c(%r15), %eax
movw %ax, 0x46(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: decodeIntArray
static void decodeIntArray(
  char *zIntArray,       /* String containing int array to decode */
  int nOut,              /* Number of slots in aOut[] */
  tRowcnt *aOut,         /* Store integers here */
  Index *pIndex          /* Handle extra flags for this index, if not NULL */
){
  char *z = zIntArray;
  int c;
  int i;
  tRowcnt v;

#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  if( z==0 ) z = "";
#else
  if( NEVER(z==0) ) z = "";
#endif
  for(i=0; *z && i<nOut; i++){
    v = 0;
    while( (c=z[0])>='0' && c<='9' ){
      v = v*10 + c - '0';
      z++;
    }
    aOut[i] = v;
    if( *z==' ' ) z++;
  }
#ifndef SQLITE_ENABLE_STAT3_OR_STAT4
  assert( pIndex!=0 );
#else
  if( pIndex )
#endif
  {
    if( strcmp(z, "unordered")==0 ){
      pIndex->bUnordered = 1;
    }else if( sqlite3_strglob("sz=[0-9]*", z)==0 ){
      int v32 = 0;
      sqlite3GetInt32(z+3, &v32);
      pIndex->szIdxRow = sqlite3LogEst(v32);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
testq %rdi, %rdi
leaq 0x3dda4(%rip), %r14     # 0x72fe4
cmovneq %rdi, %r14
cmpb $0x0, (%r14)
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x352a8
movl %esi, %eax
xorl %ecx, %ecx
movb (%r14), %dil
leal -0x30(%rdi), %esi
cmpb $0x9, %sil
ja 0x35286
xorl %esi, %esi
movzbl %dil, %edi
leal (%rsi,%rsi,4), %esi
leal (%rdi,%rsi,2), %esi
addl $-0x30, %esi
movb 0x1(%r14), %dil
incq %r14
leal -0x30(%rdi), %r8d
cmpb $0xa, %r8b
jb 0x35266
jmp 0x35288
xorl %esi, %esi
movl %esi, (%rdx,%rcx,4)
xorl %esi, %esi
cmpb $0x20, (%r14)
sete %sil
cmpb $0x0, (%r14,%rsi)
leaq (%r14,%rsi), %r14
je 0x352a8
incq %rcx
cmpq %rax, %rcx
jb 0x35258
leaq 0x3bb83(%rip), %rsi     # 0x70e32
movq %r14, %rdi
callq 0x73c0
testl %eax, %eax
je 0x35300
leaq 0x3bb7a(%rip), %rdi     # 0x70e3c
leaq 0x381f7(%rip), %rdx     # 0x6d4c0
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x12960
testl %eax, %eax
je 0x35304
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
addq $0x3, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x34d9c
movslq (%r15), %rdi
callq 0x3530e
movw %ax, 0x5c(%rbx)
jmp 0x35304
orb $0x4, 0x63(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3LogEst
SQLITE_PRIVATE LogEst sqlite3LogEst(u64 x){
  static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
  LogEst y = 40;
  if( x<8 ){
    if( x<2 ) return 0;
    while( x<8 ){  y -= 10; x <<= 1; }
  }else{
    while( x>255 ){ y += 40; x >>= 4; }
    while( x>15 ){  y += 10; x >>= 1; }
  }
  return a[x&7] + y - 10;
}

// Assembly:
cmpq $0x8, %rdi
jae 0x3531d
cmpq $0x2, %rdi
jae 0x35346
xorl %eax, %eax
retq
movw $0x28, %ax
cmpq $0x100, %rdi            # imm = 0x100
jb 0x3535c
movw $0x28, %ax
movq %rdi, %rcx
addl $0x28, %eax
shrq $0x4, %rcx
cmpq $0xfff, %rdi            # imm = 0xFFF
movq %rcx, %rdi
ja 0x35331
jmp 0x3535f
movw $0x28, %ax
addl $-0xa, %eax
leaq (%rdi,%rdi), %rdx
cmpq $0x4, %rdi
movq %rdx, %rdi
jb 0x3534a
jmp 0x3537c
movq %rdi, %rcx
cmpq $0x10, %rcx
jb 0x35379
movq %rcx, %rdx
addl $0xa, %eax
shrq %rdx
cmpq $0x1f, %rcx
movq %rdx, %rcx
ja 0x35368
jmp 0x3537c
movq %rcx, %rdx
andl $0x7, %edx
leaq 0x3ad8a(%rip), %rcx     # 0x70110
addw (%rcx,%rdx,2), %ax
addl $-0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: freeIndex
static void freeIndex(sqlite3 *db, Index *p){
#ifndef SQLITE_OMIT_ANALYZE
  sqlite3DeleteIndexSamples(db, p);
#endif
  if( db==0 || db->pnBytesFreed==0 ) sqlite3KeyInfoUnref(p->pKeyInfo);
  sqlite3ExprDelete(db, p->pPartIdxWhere);
  sqlite3DbFree(db, p->zColAff);
  if( p->isResized ) sqlite3DbFree(db, p->azColl);
  sqlite3DbFree(db, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x356dc
cmpq $0x0, 0x318(%r14)
jne 0x356ee
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x356ee
decl (%rdi)
jne 0x356ee
callq 0xa3cf
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x3572a
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x9b58
testb $0x10, 0x63(%rbx)
je 0x35718
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x9b58
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b58
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ExprDelete
SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
  if( p==0 ) return;
  /* Sanity check: Assert that the IntValue is non-negative if it exists */
  assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
  if( !ExprHasProperty(p, EP_TokenOnly) ){
    /* The Expr.x union is never used at the same time as Expr.pRight */
    assert( p->x.pList==0 || p->pRight==0 );
    sqlite3ExprDelete(db, p->pLeft);
    sqlite3ExprDelete(db, p->pRight);
    if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
    if( ExprHasProperty(p, EP_xIsSelect) ){
      sqlite3SelectDelete(db, p->x.pSelect);
    }else{
      sqlite3ExprListDelete(db, p->x.pList);
    }
  }
  if( !ExprHasProperty(p, EP_Static) ){
    sqlite3DbFree(db, p);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3579a
movq %rsi, %rbx
movq %rdi, %r14
testb $0x40, 0x5(%rsi)
jne 0x35782
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x3572a
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x3572a
testb $0x1, 0x6(%rbx)
je 0x35769
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x9b58
testb $0x8, 0x5(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
jne 0x3577d
callq 0x357c9
jmp 0x35782
callq 0x357a2
testb $-0x80, 0x5(%rbx)
jne 0x3579a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b58
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeGetAutoVacuum
SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *p){
#ifdef SQLITE_OMIT_AUTOVACUUM
  return BTREE_AUTOVACUUM_NONE;
#else
  int rc;
  sqlite3BtreeEnter(p);
  rc = (
    (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
    (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
    BTREE_AUTOVACUUM_INCR
  );
  sqlite3BtreeLeave(p);
  return rc;
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd284
movq 0x8(%rbx), %rax
cmpb $0x0, 0x21(%rax)
je 0x368fd
cmpb $0x1, 0x22(%rax)
movl $0x2, %ebp
sbbl $0x0, %ebp
jmp 0x368ff
xorl %ebp, %ebp
cmpb $0x0, 0x11(%rbx)
je 0x3691d
decl 0x14(%rbx)
jne 0x3691d
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x36919
callq *0x52a0f(%rip)          # 0x89328
movb $0x0, 0x12(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3AddColumnType
SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
  Table *p;
  Column *pCol;

  p = pParse->pNewTable;
  if( p==0 || NEVER(p->nCol<1) ) return;
  pCol = &p->aCol[p->nCol-1];
  assert( pCol->zType==0 );
  pCol->zType = sqlite3NameFromToken(pParse->db, pType);
  pCol->affinity = sqlite3AffinityType(pCol->zType, &pCol->szEst);
}

// Assembly:
movq 0x240(%rdi), %rax
testq %rax, %rax
je 0x3b74c
movswq 0x42(%rax), %rcx
testq %rcx, %rcx
jle 0x3b74c
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rax), %rbx
decl %ecx
leaq (%rcx,%rcx,2), %r14
shlq $0x4, %r14
movq (%rdi), %rdi
callq 0x4cba0
addq %r14, %rbx
addq $0x2a, %rbx
movq %rax, -0x12(%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x498e1
movb %al, -0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3OpenTable
SQLITE_PRIVATE void sqlite3OpenTable(
  Parse *pParse,  /* Generate code into this VDBE */
  int iCur,       /* The cursor number of the table */
  int iDb,        /* The database index in sqlite3.aDb[] */
  Table *pTab,    /* The table to be opened */
  int opcode      /* OP_OpenRead or OP_OpenWrite */
){
  Vdbe *v;
  assert( !IsVirtual(pTab) );
  v = sqlite3GetVdbe(pParse);
  assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
  sqlite3TableLock(pParse, iDb, pTab->tnum, 
                   (opcode==OP_OpenWrite)?1:0, pTab->zName);
  if( HasRowid(pTab) ){
    sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
    VdbeComment((v, "%s", pTab->zName));
  }else{
    Index *pPk = sqlite3PrimaryKeyIndex(pTab);
    assert( pPk!=0 );
    assert( pPk->tnum=pTab->tnum );
    sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
    sqlite3VdbeSetP4KeyInfo(pParse, pPk);
    VdbeComment((v, "%s", pTab->zName));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r13
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x47f6a
movq %rax, %r12
movl 0x3c(%r13), %edx
xorl %ecx, %ecx
cmpl $0x33, %ebp
sete %cl
movq (%r13), %r8
movq %r15, %rdi
movl %ebx, %esi
callq 0x4814a
testb $0x20, 0x48(%r13)
jne 0x480eb
movl 0x3c(%r13), %ecx
movswq 0x42(%r13), %r15
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %ebx, %r8d
callq 0x47fb1
movq %r12, %rdi
movl %eax, %esi
movq %r15, %rdx
movl $0xfffffff2, %ecx       # imm = 0xFFFFFFF2
jmp 0x48137
movq 0x10(%r13), %r13
testq %r13, %r13
je 0x48104
movb 0x63(%r13), %al
andb $0x3, %al
cmpb $0x2, %al
je 0x48104
movq 0x28(%r13), %r13
jmp 0x480ef
movl 0x58(%r13), %ecx
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %ebx, %r8d
callq 0x47fb1
movq 0x10(%r15), %rbx
movq %r15, %rdi
movq %r13, %rsi
callq 0x48266
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rax, %rdx
movl $0xfffffffa, %ecx       # imm = 0xFFFFFFFA
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ea3
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3KeyInfoOfIndex
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
  if( pParse->nErr ) return 0;
#ifndef SQLITE_OMIT_SHARED_CACHE
  if( pIdx->pKeyInfo && pIdx->pKeyInfo->db!=pParse->db ){
    sqlite3KeyInfoUnref(pIdx->pKeyInfo);
    pIdx->pKeyInfo = 0;
  }
#endif
  if( pIdx->pKeyInfo==0 ){
    int i;
    int nCol = pIdx->nColumn;
    int nKey = pIdx->nKeyCol;
    KeyInfo *pKey;
    if( pIdx->uniqNotNull ){
      pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
    }else{
      pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
    }
    if( pKey ){
      assert( sqlite3KeyInfoIsWriteable(pKey) );
      for(i=0; i<nCol; i++){
        char *zColl = pIdx->azColl[i];
        if( NEVER(zColl==0) ) zColl = "BINARY";
        pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl);
        pKey->aSortOrder[i] = pIdx->aSortOrder[i];
      }
      if( pParse->nErr ){
        sqlite3KeyInfoUnref(pKey);
      }else{
        pIdx->pKeyInfo = pKey;
      }
    }
  }
  return sqlite3KeyInfoRef(pIdx->pKeyInfo);
}

// Assembly:
cmpl $0x0, 0x50(%rdi)
je 0x4826f
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x50(%rsi), %rdi
testq %rdi, %rdi
je 0x482a3
movq 0x10(%rdi), %rax
cmpq (%r14), %rax
je 0x482a3
decl (%rdi)
jne 0x4829b
callq 0xa3cf
movq $0x0, 0x50(%rbx)
cmpq $0x0, 0x50(%rbx)
je 0x482c4
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x482b5
incl (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x60(%rbx), %ebp
testb $0x8, 0x63(%rbx)
jne 0x482d7
movq (%r14), %rdi
movl %ebp, %esi
xorl %edx, %edx
jmp 0x482e2
movzwl 0x5e(%rbx), %esi
movq (%r14), %rdi
movl %ebp, %edx
subl %esi, %edx
callq 0x4835a
movq %rax, %r15
testq %rax, %rax
je 0x482aa
testl %ebp, %ebp
je 0x48334
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x287de(%rip), %rbp     # 0x70ade
movq 0x40(%rbx), %rax
movq (%rax,%r13,8), %rsi
testq %rsi, %rsi
cmoveq %rbp, %rsi
movq %r14, %rdi
callq 0x483de
movq %rax, 0x20(%r15,%r13,8)
movq 0x38(%rbx), %rax
movb (%rax,%r13), %al
movq 0x18(%r15), %rcx
movb %al, (%rcx,%r13)
incq %r13
cmpq %r13, %r12
jne 0x48300
cmpl $0x0, 0x50(%r14)
je 0x48351
decl (%r15)
jne 0x482aa
movq %r15, %rdi
callq 0xa3cf
jmp 0x482aa
movq %r15, 0x50(%rbx)
jmp 0x482aa
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3KeyInfoAlloc
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
  KeyInfo *p = sqlite3DbMallocZero(0, 
                   sizeof(KeyInfo) + (N+X)*(sizeof(CollSeq*)+1));
  if( p ){
    p->aSortOrder = (u8*)&p->aColl[N+X];
    p->nField = (u16)N;
    p->nXField = (u16)X;
    p->enc = ENC(db);
    p->db = db;
    p->nRef = 1;
  }else{
    db->mallocFailed = 1;
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
leal (%r14,%r12), %r13d
leal 0x28(%r13,%r13,8), %ebp
movl %ebp, %edi
callq 0xa35e
movq %rax, %r15
testq %rax, %rax
je 0x483c8
movslq %ebp, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x7180
movslq %r13d, %rax
leaq (%r15,%rax,8), %rax
addq $0x20, %rax
movq %rax, 0x18(%r15)
movw %r12w, 0x6(%r15)
movw %r14w, 0x8(%r15)
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rax
movb 0x71(%rax), %al
movb %al, 0x4(%r15)
movq %rbx, 0x10(%r15)
movl $0x1, (%r15)
jmp 0x483cc
movb $0x1, 0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ExprCodeTemp
SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
  int r2;
  pExpr = sqlite3ExprSkipCollate(pExpr);
  if( ConstFactorOk(pParse)
   && pExpr->op!=TK_REGISTER
   && sqlite3ExprIsConstantNotJoin(pExpr)
  ){
    ExprList *p = pParse->pConstExpr;
    int i;
    *pReg  = 0;
    if( p ){
      struct ExprList_item *pItem;
      for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
        if( pItem->reusable && sqlite3ExprCompare(pItem->pExpr,pExpr,-1)==0 ){
          return pItem->u.iConstExprReg;
        }
      }
    }
    r2 = ++pParse->nMem;
    sqlite3ExprCodeAtInit(pParse, pExpr, r2, 1);
  }else{
    int r1 = sqlite3GetTempReg(pParse);
    r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
    if( r2==r1 ){
      *pReg = r1;
    }else{
      sqlite3ReleaseTempReg(pParse, r1);
      *pReg = 0;
    }
  }
  return r2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x49a96
movl 0x4(%r14), %eax
btl $0xc, %eax
jae 0x49a96
btl $0x12, %eax
jb 0x49a86
addq $0x10, %r14
jmp 0x49a8e
movq 0x20(%r14), %rax
movq 0x8(%rax), %r14
movq (%r14), %r14
testq %r14, %r14
jne 0x49a70
cmpl $0x0, 0x178(%rbx)
jle 0x49b6f
movq (%rbx), %rax
testb $0x8, 0x4c(%rax)
jne 0x49b6f
cmpb $-0x7b, (%r14)
je 0x49b6f
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movaps %xmm0, 0x10(%r12)
movq $0x0, 0x20(%r12)
movl $0x3, 0x20(%r12)
leaq 0x1b02(%rip), %rax      # 0x4b5e6
movq %rax, (%r12)
leaq 0x1b3a(%rip), %rax      # 0x4b629
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x4b636
cmpl $0x0, 0x20(%r12)
je 0x49b6f
movq 0x168(%rbx), %rax
movl $0x0, (%r15)
testq %rax, %rax
je 0x49c07
movl (%rax), %r15d
testl %r15d, %r15d
setle %r12b
jle 0x49bfb
movq 0x8(%rax), %r13
addq $0x1c, %r13
incl %r15d
testb $0x4, -0x3(%r13)
je 0x49b59
movq -0x1c(%r13), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4b3cb
testl %eax, %eax
je 0x49bfd
addq $0x20, %r13
decl %r15d
cmpl $0x2, %r15d
setl %r12b
jge 0x49b39
jmp 0x49c01
movb 0x1f(%rbx), %al
testb %al, %al
je 0x49b85
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0x28(%rbx,%rax,4), %r12d
jmp 0x49b90
movl 0x58(%rbx), %r12d
incl %r12d
movl %r12d, 0x58(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x4873c
movl %eax, %ebp
cmpl %r12d, %eax
jne 0x49baa
movl %r12d, %ecx
jmp 0x49be7
xorl %ecx, %ecx
testl %r12d, %r12d
je 0x49be7
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x49be7
xorl %ecx, %ecx
cmpl %r12d, 0x84(%rbx,%rcx)
je 0x49be0
addq $0x18, %rcx
cmpl $0xf0, %ecx
jne 0x49bbd
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %r12d, 0x28(%rbx,%rax,4)
jmp 0x49be5
movb $0x1, 0x7c(%rbx,%rcx)
xorl %ecx, %ecx
movl %ecx, (%r15)
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49c01
movl (%r13), %ebp
testb $0x1, %r12b
je 0x49bea
movl 0x58(%rbx), %ebp
incl %ebp
movl %ebp, 0x58(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x4b576
jmp 0x49bea
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ExprCodeExprList
SQLITE_PRIVATE int sqlite3ExprCodeExprList(
  Parse *pParse,     /* Parsing context */
  ExprList *pList,   /* The expression list to be coded */
  int target,        /* Where to write results */
  u8 flags           /* SQLITE_ECEL_* flags */
){
  struct ExprList_item *pItem;
  int i, n;
  u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy;
  assert( pList!=0 );
  assert( target>0 );
  assert( pParse->pVdbe!=0 );  /* Never gets this far otherwise */
  n = pList->nExpr;
  if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
  for(pItem=pList->a, i=0; i<n; i++, pItem++){
    Expr *pExpr = pItem->pExpr;
    if( (flags & SQLITE_ECEL_FACTOR)!=0 && sqlite3ExprIsConstant(pExpr) ){
      sqlite3ExprCodeAtInit(pParse, pExpr, target+i, 0);
    }else{
      int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
      if( inReg!=target+i ){
        sqlite3VdbeAddOp2(pParse->pVdbe, copyOp, inReg, target+i);
      }
    }
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rdi, %r14
movl (%rsi), %r13d
cmpl $0x0, 0x178(%rdi)
jle 0x49f31
movq (%r14), %rax
testb $0x8, 0x4c(%rax)
movl %ecx, %r15d
je 0x49f34
xorl %r15d, %r15d
testl %r13d, %r13d
jle 0x49fe7
andb $0x1, %cl
xorb $0x1f, %cl
movq 0x8(%rsi), %rbp
movzbl %cl, %eax
movl %eax, 0xc(%rsp)
movq (%rbp), %r12
testb $0x2, %r15b
je 0x49fb3
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x1669(%rip), %rax      # 0x4b5e6
movq %rax, 0x10(%rsp)
leaq 0x16a0(%rip), %rax      # 0x4b629
movq %rax, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x4b636
cmpl $0x0, 0x30(%rsp)
je 0x49fb3
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x4b576
jmp 0x49fd8
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x4873c
cmpl %eax, %ebx
je 0x49fd8
movq 0x10(%r14), %rdi
movl 0xc(%rsp), %esi
movl %eax, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x47fb1
addq $0x20, %rbp
incl %ebx
decl %r13d
jne 0x49f4e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3HaltConstraint
SQLITE_PRIVATE void sqlite3HaltConstraint(
  Parse *pParse,    /* Parsing context */
  int errCode,      /* extended error code */
  int onError,      /* Constraint type */
  char *p4,         /* Error message */
  i8 p4type,        /* P4_STATIC or P4_TRANSIENT */
  u8 p5Errmsg       /* P5_ErrMsg type */
){
  Vdbe *v = sqlite3GetVdbe(pParse);
  assert( (errCode&0xff)==SQLITE_CONSTRAINT );
  if( onError==OE_Abort ){
    sqlite3MayAbort(pParse);
  }
  sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
  if( p5Errmsg ) sqlite3VdbeChangeP5(v, p5Errmsg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %r13d
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
callq 0x47f6a
movq %rax, %r14
cmpl $0x2, %ebp
jne 0x4ad88
movq 0x1e0(%rbx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
movb $0x1, 0x24(%rax)
movsbl %r13b, %ebx
movq %r14, %rdi
movl $0x16, %esi
movl %r12d, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x47fb1
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x11ea3
movl 0x4(%rsp), %edx
testb %dl, %dl
je 0x4adcd
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4adcd
movslq 0x34(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
movb %dl, -0x15(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ExprCodeGetColumnOfTable
SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(
  Vdbe *v,        /* The VDBE under construction */
  Table *pTab,    /* The table containing the value */
  int iTabCur,    /* The table cursor.  Or the PK cursor for WITHOUT ROWID */
  int iCol,       /* Index of the column to extract */
  int regOut      /* Extract the value into this register */
){
  if( iCol<0 || iCol==pTab->iPKey ){
    sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
  }else{
    int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
    int x = iCol;
    if( !HasRowid(pTab) ){
      x = sqlite3ColumnOfIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
    }
    sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut);
  }
  if( iCol>=0 ){
    sqlite3ColumnDefault(v, pTab, iCol, regOut);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
js 0x4adfb
movswl 0x40(%r14), %eax
cmpl %ebp, %eax
jne 0x4ae0a
movq %r15, %rdi
movl $0x62, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
jmp 0x4ae7a
movzbl 0x48(%r14), %eax
testb $0x10, %al
movl $0x2b, %ecx
movl $0x8c, %esi
cmovel %ecx, %esi
movl %ebp, %ecx
testb $0x20, %al
je 0x4ae74
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x4ae3e
movb 0x63(%rax), %cl
andb $0x3, %cl
cmpb $0x2, %cl
je 0x4ae3e
movq 0x28(%rax), %rax
jmp 0x4ae28
movzwl 0x60(%rax), %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x4ae74
movq 0x8(%rax), %rax
shll $0x10, %edi
xorl %r8d, %r8d
cmpw %bp, (%rax)
je 0x4ae6d
addq $0x10000, %r8           # imm = 0x10000
addq $0x2, %rax
cmpq %r8, %rdi
jne 0x4ae56
jmp 0x4ae74
sarl $0x10, %r8d
movl %r8d, %ecx
movq %r15, %rdi
movl %ebx, %r8d
callq 0x47fb1
testl %ebp, %ebp
js 0x4ae9c
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4af4f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ExprCodeAtInit
SQLITE_PRIVATE void sqlite3ExprCodeAtInit(
  Parse *pParse,    /* Parsing context */
  Expr *pExpr,      /* The expression to code when the VDBE initializes */
  int regDest,      /* Store the value in this register */
  u8 reusable       /* True if this expression is reusable */
){
  ExprList *p;
  assert( ConstFactorOk(pParse) );
  p = pParse->pConstExpr;
  pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
  p = sqlite3ExprListAppend(pParse, p, pExpr);
  if( p ){
     struct ExprList_item *pItem = &p->a[p->nExpr-1];
     pItem->u.iConstExprReg = regDest;
     pItem->reusable = reusable;
  }
  pParse->pConstExpr = p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x168(%rbx), %r15
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4b8a1
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3ef23
testq %rax, %rax
je 0x4b5d4
movq 0x8(%rax), %rcx
movslq (%rax), %rdx
shlq $0x5, %rdx
movl %r14d, -0x4(%rcx,%rdx)
movb -0x7(%rcx,%rdx), %sil
shlb $0x2, %bpl
andb $0x4, %bpl
andb $-0x5, %sil
orb %bpl, %sil
movb %sil, -0x7(%rcx,%rdx)
movq %rax, 0x168(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: exprCodeBetween
static void exprCodeBetween(
  Parse *pParse,    /* Parsing and code generating context */
  Expr *pExpr,      /* The BETWEEN expression */
  int dest,         /* Jump here if the jump is taken */
  int jumpIfTrue,   /* Take the jump if the BETWEEN is true */
  int jumpIfNull    /* Take the jump if the BETWEEN is NULL */
){
  Expr exprAnd;     /* The AND operator in  x>=y AND x<=z  */
  Expr compLeft;    /* The  x>=y  term */
  Expr compRight;   /* The  x<=z  term */
  Expr exprX;       /* The  x  subexpression */
  int regFree1 = 0; /* Temporary use register */

  assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
  exprX = *pExpr->pLeft;
  exprAnd.op = TK_AND;
  exprAnd.pLeft = &compLeft;
  exprAnd.pRight = &compRight;
  compLeft.op = TK_GE;
  compLeft.pLeft = &exprX;
  compLeft.pRight = pExpr->x.pList->a[0].pExpr;
  compRight.op = TK_LE;
  compRight.pLeft = &exprX;
  compRight.pRight = pExpr->x.pList->a[1].pExpr;
  exprToRegister(&exprX, sqlite3ExprCodeTemp(pParse, &exprX, &regFree1));
  if( jumpIfTrue ){
    sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
  }else{
    sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
  }
  sqlite3ReleaseTempReg(pParse, regFree1);

  /* Ensure adequate test coverage */
  testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
  testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
  testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
  testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
  testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
  testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
  testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
  testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r14d
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x10(%rsi), %rsi
leaq 0x58(%rsp), %r12
movl $0x9, %ecx
movq %r12, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x46, 0x10(%rsp)
leaq 0xe8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
leaq 0xa0(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movb $0x51, (%rcx)
movq %r12, 0x10(%rcx)
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq %rdi, 0x18(%rcx)
movb $0x4f, (%rsi)
movq %r12, 0x10(%rsi)
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x49a54
movb (%r12), %cl
movb %cl, 0x36(%r12)
movb $-0x7b, (%r12)
movl %eax, 0x2c(%r12)
andb $-0x11, 0x5(%r12)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
testl %r15d, %r15d
je 0x4cad8
callq 0x4c753
jmp 0x4cadd
callq 0x4aa7d
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x4cb17
movzbl 0x1f(%rbx), %ecx
cmpq $0x7, %rcx
ja 0x4cb17
xorl %edx, %edx
cmpl %eax, 0x84(%rbx,%rdx)
je 0x4cb12
addq $0x18, %rdx
cmpl $0xf0, %edx
jne 0x4caf1
leal 0x1(%rcx), %edx
movb %dl, 0x1f(%rbx)
movl %eax, 0x28(%rbx,%rcx,4)
jmp 0x4cb17
movb $0x1, 0x7c(%rbx,%rdx)
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3Dequote
SQLITE_PRIVATE int sqlite3Dequote(char *z){
  char quote;
  int i, j;
  if( z==0 ) return -1;
  quote = z[0];
  switch( quote ){
    case '\'':  break;
    case '"':   break;
    case '`':   break;                /* For MySQL compatibility */
    case '[':   quote = ']';  break;  /* For MS SqlServer compatibility */
    default:    return -1;
  }
  for(i=1, j=0;; i++){
    assert( z[i] );
    if( z[i]==quote ){
      if( z[i+1]==quote ){
        z[j++] = quote;
        i++;
      }else{
        break;
      }
    }else{
      z[j++] = z[i];
    }
  }
  z[j] = 0;
  return j;
}

// Assembly:
testq %rdi, %rdi
je 0x4cc0c
movb (%rdi), %al
movzbl %al, %ecx
cmpl $0x5a, %ecx
jg 0x4cc0d
cmpl $0x22, %ecx
je 0x4cc19
cmpl $0x27, %ecx
je 0x4cc19
retq
cmpl $0x60, %ecx
je 0x4cc19
cmpl $0x5b, %ecx
jne 0x4cc0c
movb $0x5d, %al
movl $0x1, %edx
xorl %ecx, %ecx
movslq %edx, %rsi
movb (%rdi,%rsi), %r8b
cmpb %al, %r8b
jne 0x4cc3a
cmpb %al, 0x1(%rdi,%rsi)
jne 0x4cc45
incq %rsi
movl %eax, %r8d
movl %esi, %edx
movb %r8b, (%rdi,%rcx)
incq %rcx
incl %edx
jmp 0x4cc20
movl %ecx, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3OpenMasterTable
SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
  Vdbe *v = sqlite3GetVdbe(p);
  sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
  sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);
  if( p->nTab==0 ){
    p->nTab = 1;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x47f6a
movq %rax, %r14
cmpl $0x1, %ebp
leaq 0x23f07(%rip), %rax     # 0x70cce
leaq 0x23f13(%rip), %r8      # 0x70ce1
cmoveq %rax, %r8
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x4814a
movq %r14, %rdi
movl $0x33, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x47fb1
movl $0x5, %edx
movq %r14, %rdi
movl %eax, %esi
movl $0xfffffff2, %ecx       # imm = 0xFFFFFFF2
callq 0x11ea3
cmpl $0x0, 0x54(%rbx)
jne 0x4ce1e
movl $0x1, 0x54(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: estimateIndexWidth
static void estimateIndexWidth(Index *pIdx){
  unsigned wIndex = 0;
  int i;
  const Column *aCol = pIdx->pTable->aCol;
  for(i=0; i<pIdx->nColumn; i++){
    i16 x = pIdx->aiColumn[i];
    assert( x<pIdx->pTable->nCol );
    wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
  }
  pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0x60(%rdi), %eax
xorl %edi, %edi
testq %rax, %rax
je 0x4d2bf
movq 0x18(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movswq (%rdx,%rsi,2), %r8
testq %r8, %r8
js 0x4d2ab
leaq (%r8,%r8,2), %r8
shlq $0x4, %r8
movzbl 0x2a(%rcx,%r8), %r8d
jmp 0x4d2b1
movl $0x1, %r8d
addl %r8d, %edi
incq %rsi
cmpq %rsi, %rax
jne 0x4d291
shll $0x2, %edi
callq 0x3530e
movw %ax, 0x5c(%rbx)
popq %rbx
retq