LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x3e99f(%rip), %r14     # 0x74084
cmovneq %rdi, %r14
movb (%r14), %dil
testb %dil, %dil
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x3574d
movl %esi, %eax
xorl %ecx, %ecx
leal -0x30(%rdi), %esi
cmpb $0x9, %sil
ja 0x3572a
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 0x3570a
jmp 0x3572c
xorl %esi, %esi
movl %esi, (%rdx,%rcx,4)
xorl %esi, %esi
cmpb $0x20, (%r14)
sete %sil
movb (%r14,%rsi), %dil
addq %rsi, %r14
testb %dil, %dil
je 0x3574d
incq %rcx
cmpq %rax, %rcx
jb 0x356ff
leaq 0x3c77e(%rip), %rsi     # 0x71ed2
movq %r14, %rdi
callq 0x73c0
testl %eax, %eax
je 0x357a5
leaq 0x3c775(%rip), %rdi     # 0x71edc
leaq 0x38d92(%rip), %rdx     # 0x6e500
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x12b14
testl %eax, %eax
je 0x357a9
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
addq $0x3, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x35230
movslq (%r15), %rdi
callq 0x357b3
movw %ax, 0x5c(%rbx)
jmp 0x357a9
orb $0x4, 0x63(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x357c2
cmpq $0x2, %rdi
jae 0x357eb
xorl %eax, %eax
retq
movw $0x28, %ax
cmpq $0x100, %rdi            # imm = 0x100
jb 0x35801
movw $0x28, %ax
movq %rdi, %rcx
addl $0x28, %eax
shrq $0x4, %rcx
cmpq $0xfff, %rdi            # imm = 0xFFF
movq %rcx, %rdi
ja 0x357d6
jmp 0x35804
movw $0x28, %ax
addl $-0xa, %eax
leaq (%rdi,%rdi), %rdx
cmpq $0x4, %rdi
movq %rdx, %rdi
jb 0x357ef
jmp 0x35821
movq %rdi, %rcx
cmpq $0x10, %rcx
jb 0x3581e
movq %rcx, %rdx
addl $0xa, %eax
shrq %rdx
cmpq $0x1f, %rcx
movq %rdx, %rcx
ja 0x3580d
jmp 0x35821
movq %rcx, %rdx
andl $0x7, %edx
leaq 0x3b985(%rip), %rcx     # 0x711b0
addw (%rcx,%rdx,2), %ax
addl $-0xa, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x35b7c
cmpq $0x0, 0x318(%r14)
jne 0x35b8e
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x35b8e
decl (%rdi)
jne 0x35b8e
callq 0xa4bf
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x35bca
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x9b42
testb $0x10, 0x63(%rbx)
je 0x35bb8
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x9b42
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b42
// File: /workspace/github_c_makefile_star2_O3/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 0x35c40
movq %rsi, %rbx
movq %rdi, %r14
testb $0x40, 0x5(%rsi)
jne 0x35c28
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x35bca
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x35bca
movl 0x4(%rbx), %eax
btl $0x10, %eax
jae 0x35c0f
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x9b42
movl 0x4(%rbx), %eax
btl $0xb, %eax
movq 0x20(%rbx), %rsi
movq %r14, %rdi
jb 0x35c23
callq 0x35c6f
jmp 0x35c28
callq 0x35c48
testb $-0x80, 0x5(%rbx)
jne 0x35c40
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b42
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeSetAutoVacuum
SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
#ifdef SQLITE_OMIT_AUTOVACUUM
  return SQLITE_READONLY;
#else
  BtShared *pBt = p->pBt;
  int rc = SQLITE_OK;
  u8 av = (u8)autoVacuum;

  sqlite3BtreeEnter(p);
  if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
    rc = SQLITE_READONLY;
  }else{
    pBt->autoVacuum = av ?1:0;
    pBt->incrVacuum = av==2 ?1:0;
  }
  sqlite3BtreeLeave(p);
  return rc;
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
callq 0xd3a2
testb $0x2, 0x26(%r14)
movzbl %bpl, %eax
je 0x36d2c
testl %eax, %eax
setne %cl
movl $0x8, %ebp
cmpb %cl, 0x21(%r14)
jne 0x36d3d
testl %eax, %eax
setne 0x21(%r14)
cmpl $0x2, %eax
sete 0x22(%r14)
xorl %ebp, %ebp
cmpb $0x0, 0x11(%rbx)
je 0x36d5f
decl 0x14(%rbx)
jne 0x36d5f
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x36d5b
callq *0x535cd(%rip)          # 0x8a328
movb $0x0, 0x12(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd3a2
movq 0x8(%rbx), %rax
cmpb $0x0, 0x21(%rax)
je 0x36d89
cmpb $0x1, 0x22(%rax)
movl $0x2, %ebp
sbbl $0x0, %ebp
jmp 0x36d8b
xorl %ebp, %ebp
cmpb $0x0, 0x11(%rbx)
je 0x36da9
decl 0x14(%rbx)
jne 0x36da9
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x36da5
callq *0x53583(%rip)          # 0x8a328
movb $0x0, 0x12(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3bb57
movswq 0x42(%rax), %rcx
testq %rcx, %rcx
jle 0x3bb57
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rax), %rbx
decl %ecx
leaq (%rcx,%rcx,2), %r14
shlq $0x4, %r14
movq (%rdi), %rdi
callq 0x4d2b8
addq %r14, %rbx
addq $0x2a, %rbx
movq %rax, -0x12(%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4a157
movb %al, -0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x48791
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 0x48985
testb $0x20, 0x48(%r13)
jne 0x48923
movl 0x3c(%r13), %ecx
movswq 0x42(%r13), %r15
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %ebx, %r8d
callq 0x487d8
movq %r12, %rdi
movl %eax, %esi
movq %r15, %rdx
movl $0xfffffff2, %ecx       # imm = 0xFFFFFFF2
jmp 0x48972
movq 0x10(%r13), %r13
testq %r13, %r13
je 0x4893c
movb 0x63(%r13), %al
andb $0x3, %al
cmpb $0x2, %al
je 0x4893f
movq 0x28(%r13), %r13
jmp 0x48927
xorl %r13d, %r13d
movl 0x58(%r13), %ecx
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
movl %ebx, %r8d
callq 0x487d8
movq 0x10(%r15), %rbx
movq %r15, %rdi
movq %r13, %rsi
callq 0x48a99
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 0x12044
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x50(%rdi)
je 0x48ab2
xorl %r14d, %r14d
jmp 0x48b7c
movq %rsi, %rbx
movq %rdi, %r15
movq 0x50(%rsi), %r14
testq %r14, %r14
je 0x48ae3
movq 0x10(%r14), %rax
cmpq (%r15), %rax
je 0x48b79
decl (%r14)
jne 0x48adb
movq %r14, %rdi
callq 0xa4bf
movq $0x0, 0x50(%rbx)
movzwl 0x60(%rbx), %ebp
testb $0x8, 0x63(%rbx)
jne 0x48af6
movq (%r15), %rdi
movl %ebp, %esi
xorl %edx, %edx
jmp 0x48b01
movzwl 0x5e(%rbx), %esi
movq (%r15), %rdi
movl %ebp, %edx
subl %esi, %edx
callq 0x48b8e
movq %rax, %r14
testq %rax, %rax
je 0x48b67
testl %ebp, %ebp
je 0x48b53
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x2905f(%rip), %rbp     # 0x71b7e
movq 0x40(%rbx), %rax
movq (%rax,%r13,8), %rsi
testq %rsi, %rsi
cmoveq %rbp, %rsi
movq %r15, %rdi
callq 0x48c12
movq %rax, 0x20(%r14,%r13,8)
movq 0x38(%rbx), %rax
movb (%rax,%r13), %al
movq 0x18(%r14), %rcx
movb %al, (%rcx,%r13)
incq %r13
cmpq %r13, %r12
jne 0x48b1f
cmpl $0x0, 0x50(%r15)
je 0x48b75
decl (%r14)
jne 0x48b67
movq %r14, %rdi
callq 0xa4bf
movq 0x50(%rbx), %r14
testq %r14, %r14
jne 0x48b79
jmp 0x48aaa
movq %r14, 0x50(%rbx)
incl (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa44e
movq %rax, %r15
testq %rax, %rax
je 0x48bfc
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 0x48c00
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_O3/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4a2fd
movq %rsi, %r15
movl 0x4(%r15), %eax
btl $0xc, %eax
jae 0x4a300
btl $0x12, %eax
jb 0x4a2ed
addq $0x10, %r15
jmp 0x4a2f5
movq 0x20(%r15), %rax
movq 0x8(%rax), %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x4a2d7
xorl %r15d, %r15d
cmpl $0x0, 0x178(%rbx)
jle 0x4a3d8
movq (%rbx), %rax
testb $0x8, 0x4c(%rax)
jne 0x4a3d8
cmpb $-0x7b, (%r15)
je 0x4a3d8
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %r12
movups %xmm0, 0x10(%r12)
movq $0x0, 0x20(%r12)
movl $0x3, 0x20(%r12)
leaq 0x1a4c(%rip), %rax      # 0x4bd97
movq %rax, (%r12)
leaq 0x1a84(%rip), %rax      # 0x4bdda
movq %rax, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4bde7
cmpl $0x0, 0x20(%r12)
je 0x4a3d8
movq 0x168(%rbx), %rax
movl $0x0, (%r14)
testq %rax, %rax
je 0x4a3bc
movl (%rax), %ebp
testl %ebp, %ebp
jle 0x4a3bc
movq 0x8(%rax), %r14
addq $0x1c, %r14
incl %ebp
testb $0x4, -0x3(%r14)
je 0x4a3b1
movq -0x1c(%r14), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4bb7c
testl %eax, %eax
je 0x4a462
addq $0x20, %r14
decl %ebp
cmpl $0x2, %ebp
jge 0x4a391
movl 0x58(%rbx), %ebp
incl %ebp
movl %ebp, 0x58(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x4bd27
jmp 0x4a453
movb 0x1f(%rbx), %al
testb %al, %al
je 0x4a3ee
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0x28(%rbx,%rax,4), %r12d
jmp 0x4a3f9
movl 0x58(%rbx), %r12d
incl %r12d
movl %r12d, 0x58(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x48f5a
movl %eax, %ebp
cmpl %r12d, %eax
jne 0x4a413
movl %r12d, %ecx
jmp 0x4a450
xorl %ecx, %ecx
testl %r12d, %r12d
je 0x4a450
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x4a450
xorl %ecx, %ecx
cmpl %r12d, 0x84(%rbx,%rcx)
je 0x4a449
addq $0x18, %rcx
cmpl $0xf0, %ecx
jne 0x4a426
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %r12d, 0x28(%rbx,%rax,4)
jmp 0x4a44e
movb $0x1, 0x7c(%rbx,%rcx)
xorl %ecx, %ecx
movl %ecx, (%r14)
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl (%r14), %ebp
jmp 0x4a453
// File: /workspace/github_c_makefile_star2_O3/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 0x4a74d
movq (%r14), %rax
testb $0x8, 0x4c(%rax)
movl %ecx, %r15d
je 0x4a750
xorl %r15d, %r15d
testl %r13d, %r13d
jle 0x4a800
andb $0x1, %cl
xorb $0x1f, %cl
movq 0x8(%rsi), %rbp
movzbl %cl, %eax
movl %eax, 0xc(%rsp)
movq (%rbp), %r12
testb $0x2, %r15b
je 0x4a7cc
leaq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x1, 0x30(%rsp)
leaq 0x1601(%rip), %rax      # 0x4bd97
movq %rax, 0x10(%rsp)
leaq 0x1638(%rip), %rax      # 0x4bdda
movq %rax, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x4bde7
cmpl $0x0, 0x30(%rsp)
je 0x4a7cc
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x4bd27
jmp 0x4a7f1
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x48f5a
cmpl %eax, %ebx
je 0x4a7f1
movq 0x10(%r14), %rdi
movl 0xc(%rsp), %esi
movl %eax, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x487d8
addq $0x20, %rbp
incl %ebx
decl %r13d
jne 0x4a76a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12d
movq %rcx, %r15
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x48791
movq %rax, %r14
cmpl $0x2, %r13d
jne 0x4b58a
movq 0x1e0(%rbx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
movb $0x1, 0x24(%rax)
movl $0x2, %r13d
movsbl %r12b, %ebx
movq %r14, %rdi
movl $0x16, %esi
movl %ebp, %edx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x487d8
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x12044
movl 0x4(%rsp), %edx
testb %dl, %dl
je 0x4b5cf
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x4b5cf
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_O3/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 0x4b5fd
movswl 0x40(%r14), %eax
cmpl %ebp, %eax
jne 0x4b60c
movq %r15, %rdi
movl $0x62, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
jmp 0x4b67e
movzbl 0x48(%r14), %eax
testb $0x10, %al
movl $0x2b, %ecx
movl $0x8c, %esi
cmovel %ecx, %esi
movl %ebp, %ecx
testb $0x20, %al
je 0x4b678
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x4b640
movb 0x63(%rax), %cl
andb $0x3, %cl
cmpb $0x2, %cl
je 0x4b642
movq 0x28(%rax), %rax
jmp 0x4b62a
xorl %eax, %eax
movzwl 0x60(%rax), %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x4b678
movq 0x8(%rax), %rax
shll $0x10, %edi
xorl %r8d, %r8d
cmpw %bp, (%rax)
je 0x4b671
addq $0x10000, %r8           # imm = 0x10000
addq $0x2, %rax
cmpq %r8, %rdi
jne 0x4b65a
jmp 0x4b678
sarl $0x10, %r8d
movl %r8d, %ecx
movq %r15, %rdi
movl %ebx, %r8d
callq 0x487d8
testl %ebp, %ebp
js 0x4b6a0
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4b73d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4c052
movq (%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3f731
testq %rax, %rax
je 0x4bd85
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_O3/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 0x4a2bd
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 0x4d1f0
callq 0x4ce6b
jmp 0x4d1f5
callq 0x4b278
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x4d22f
movzbl 0x1f(%rbx), %ecx
cmpq $0x7, %rcx
ja 0x4d22f
xorl %edx, %edx
cmpl %eax, 0x84(%rbx,%rdx)
je 0x4d22a
addq $0x18, %rdx
cmpl $0xf0, %edx
jne 0x4d209
leal 0x1(%rcx), %edx
movb %dl, 0x1f(%rbx)
movl %eax, 0x28(%rbx,%rcx,4)
jmp 0x4d22f
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_O3/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 0x4d324
movb (%rdi), %al
movzbl %al, %ecx
cmpl $0x5a, %ecx
jg 0x4d325
cmpl $0x22, %ecx
je 0x4d331
cmpl $0x27, %ecx
je 0x4d331
retq
cmpl $0x60, %ecx
je 0x4d331
cmpl $0x5b, %ecx
jne 0x4d324
movb $0x5d, %al
movl $0x1, %edx
xorl %ecx, %ecx
movslq %edx, %rsi
movb (%rdi,%rsi), %r8b
cmpb %al, %r8b
jne 0x4d352
cmpb %al, 0x1(%rdi,%rsi)
jne 0x4d35d
incq %rsi
movl %eax, %r8d
movl %esi, %edx
movb %r8b, (%rdi,%rcx)
incq %rcx
incl %edx
jmp 0x4d338
movl %ecx, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x48791
movq %rax, %r14
cmpl $0x1, %ebp
leaq 0x248c1(%rip), %rax     # 0x71d6e
leaq 0x248cd(%rip), %r8      # 0x71d81
cmoveq %rax, %r8
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x48985
movq %r14, %rdi
movl $0x33, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x487d8
movl $0x5, %edx
movq %r14, %rdi
movl %eax, %esi
movl $0xfffffff2, %ecx       # imm = 0xFFFFFFF2
callq 0x12044
cmpl $0x0, 0x54(%rbx)
jne 0x4d504
movl $0x1, 0x54(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d94f
movq 0x18(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movswq (%rdx,%rsi,2), %r8
testq %r8, %r8
js 0x4d93b
leaq (%r8,%r8,2), %r8
shlq $0x4, %r8
movzbl 0x2a(%rcx,%r8), %r8d
jmp 0x4d941
movl $0x1, %r8d
addl %r8d, %edi
incq %rsi
cmpq %rsi, %rax
jne 0x4d921
shll $0x2, %edi
callq 0x357b3
movw %ax, 0x5c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: resizeIndexObject
static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
  char *zExtra;
  int nByte;
  if( pIdx->nColumn>=N ) return SQLITE_OK;
  assert( pIdx->isResized==0 );
  nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
  zExtra = sqlite3DbMallocZero(db, nByte);
  if( zExtra==0 ) return SQLITE_NOMEM;
  memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
  pIdx->azColl = (char**)zExtra;
  zExtra += sizeof(char*)*N;
  memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
  pIdx->aiColumn = (i16*)zExtra;
  zExtra += sizeof(i16)*N;
  memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
  pIdx->aSortOrder = (u8*)zExtra;
  pIdx->nColumn = N;
  pIdx->isResized = 1;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzwl 0x60(%rsi), %eax
xorl %ebp, %ebp
cmpl %edx, %eax
jge 0x4df7b
movl %edx, %r14d
movq %rsi, %rbx
leal (%r14,%r14,4), %eax
leal (%r14,%rax,2), %ebp
movl %ebp, %esi
callq 0x11c9d
testq %rax, %rax
je 0x4df76
movq %rax, %r15
movslq %ebp, %rdx
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
callq 0x7180
movl %r14d, %r12d
movq 0x40(%rbx), %rsi
movzwl 0x60(%rbx), %edx
shll $0x3, %edx
movq %r15, %rdi
callq 0x7230
movq %r15, 0x40(%rbx)
leaq (%r15,%r12,8), %r15
movq 0x8(%rbx), %rsi
movzwl 0x60(%rbx), %edx
addl %edx, %edx
movq %r15, %rdi
callq 0x7230
movq %r15, 0x8(%rbx)
leaq (%r15,%r12,2), %r15
movq 0x38(%rbx), %rsi
movzwl 0x60(%rbx), %edx
movq %r15, %rdi
callq 0x7230
movq %r15, 0x38(%rbx)
movw %r14w, 0x60(%rbx)
orb $0x10, 0x63(%rbx)
jmp 0x4df7b
movl $0x7, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: exprProbability
static int exprProbability(Expr *p){
  double r = -1.0;
  if( p->op!=TK_FLOAT ) return -1;
  sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
  assert( r>=0.0 );
  if( r>1.0 ) return -1;
  return (int)(r*1000.0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, (%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $-0x7d, (%rdi)
jne 0x4f4a0
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4f473
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rdi, %rax
incl %edx
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x4f460
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
jmp 0x4f475
xorl %edx, %edx
movq %rsp, %r14
movq %r14, %rsi
movl $0x1, %ecx
callq 0x25ede
movsd (%r14), %xmm0
ucomisd 0x21b6e(%rip), %xmm0    # 0x71000
ja 0x4f4a0
mulsd 0x21b6c(%rip), %xmm0    # 0x71008
cvttsd2si %xmm0, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: setJoinExpr
static void setJoinExpr(Expr *p, int iTable){
  while( p ){
    ExprSetProperty(p, EP_FromJoin);
    assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
    ExprSetVVAProperty(p, EP_NoReduce);
    p->iRightJoinTable = (i16)iTable;
    setJoinExpr(p->pLeft, iTable);
    p = p->pRight;
  } 
}

// Assembly:
testq %rdi, %rdi
je 0x5150b
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
orb $0x1, 0x4(%r14)
movw %bx, 0x34(%r14)
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x514d8
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x514e6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: selectAddColumnTypeAndCollation
static void selectAddColumnTypeAndCollation(
  Parse *pParse,        /* Parsing contexts */
  Table *pTab,          /* Add column type information to this table */
  Select *pSelect       /* SELECT used to determine types and collations */
){
  sqlite3 *db = pParse->db;
  NameContext sNC;
  Column *pCol;
  CollSeq *pColl;
  int i;
  Expr *p;
  struct ExprList_item *a;
  u64 szAll = 0;

  assert( pSelect!=0 );
  assert( (pSelect->selFlags & SF_Resolved)!=0 );
  assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );
  if( db->mallocFailed ) return;
  memset(&sNC, 0, sizeof(sNC));
  sNC.pSrcList = pSelect->pSrc;
  a = pSelect->pEList->a;
  for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
    p = a[i].pExpr;
    pCol->zType = sqlite3DbStrDup(db, columnType(&sNC, p,0,0,0, &pCol->szEst));
    szAll += pCol->szEst;
    pCol->affinity = sqlite3ExprAffinity(p);
    if( pCol->affinity==0 ) pCol->affinity = SQLITE_AFF_NONE;
    pColl = sqlite3ExprCollSeq(pParse, p);
    if( pColl ){
      pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
    }
  }
  pTab->szTabRow = sqlite3LogEst(szAll*4);
}

// Assembly:
movq (%rdi), %rcx
cmpb $0x0, 0x50(%rcx)
je 0x51a91
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x28(%rdx), %rax
movq %rax, 0x28(%rsp)
cmpw $0x0, 0x42(%rsi)
jle 0x51b87
movq %rcx, (%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdx), %rax
movq 0x8(%rax), %rbx
movq 0x8(%r15), %r13
addq $0x2a, %r13
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r15, 0x10(%rsp)
movq (%rbx), %rbp
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x51ba6
movq (%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x10656
movq %rax, -0x12(%r13)
movzbl (%r13), %eax
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
callq 0x4c83c
testb %al, %al
movzbl %al, %eax
movl $0x62, %ecx
cmovel %ecx, %eax
movb %al, -0x1(%r13)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x4a5fd
testq %rax, %rax
je 0x51b5e
movq (%rax), %rsi
movq %r15, %rdi
callq 0x10656
movq %rax, -0xa(%r13)
addq 0x18(%rsp), %r12
incq %r14
movq 0x10(%rsp), %r15
movswq 0x42(%r15), %rax
addq $0x20, %rbx
addq $0x30, %r13
cmpq %rax, %r14
jl 0x51af4
shlq $0x2, %r12
jmp 0x51b8a
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x357b3
movw %ax, 0x46(%r15)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3ResolveOrderGroupBy
SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(
  Parse *pParse,        /* Parsing context.  Leave error messages here */
  Select *pSelect,      /* The SELECT statement containing the clause */
  ExprList *pOrderBy,   /* The ORDER BY or GROUP BY clause to be processed */
  const char *zType     /* "ORDER" or "GROUP" */
){
  int i;
  sqlite3 *db = pParse->db;
  ExprList *pEList;
  struct ExprList_item *pItem;

  if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
#if SQLITE_MAX_COLUMN
  if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
    return 1;
  }
#endif
  pEList = pSelect->pEList;
  assert( pEList!=0 );  /* sqlite3SelectNew() guarantees this */
  for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
    if( pItem->u.x.iOrderByCol ){
      if( pItem->u.x.iOrderByCol>pEList->nExpr ){
        resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
        return 1;
      }
      resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, zType,0);
    }
  }
  return 0;
}

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
je 0x51e21
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %r14
movq (%rdi), %rdx
cmpb $0x0, 0x50(%rdx)
jne 0x51e13
movq %rcx, %rbx
movl (%r15), %ecx
cmpl 0x70(%rdx), %ecx
jle 0x51dc4
leaq 0x21579(%rip), %rsi     # 0x73329
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x11db0
movl $0x1, %eax
jmp 0x51e13
testl %ecx, %ecx
jle 0x51e13
movq (%rsi), %r13
movq 0x8(%r15), %rbp
movl $0x1, %r12d
movzwl 0x1c(%rbp), %edx
testl %edx, %edx
je 0x51e00
movl (%r13), %r8d
cmpl %edx, %r8d
jl 0x51e22
decl %edx
movq (%rbp), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x4f712
movl (%r15), %ecx
addq $0x20, %rbp
leal 0x1(%r12), %eax
cmpl %ecx, %r12d
movl %eax, %r12d
jl 0x51dd5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x214c8(%rip), %rsi     # 0x732f1
movq %r14, %rdi
movl %r12d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x11db0
jmp 0x51dbd
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3FixSelect
SQLITE_PRIVATE int sqlite3FixSelect(
  DbFixer *pFix,       /* Context of the fixation */
  Select *pSelect      /* The SELECT statement to be fixed to one database */
){
  while( pSelect ){
    if( sqlite3FixExprList(pFix, pSelect->pEList) ){
      return 1;
    }
    if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pOffset) ){
      return 1;
    }
    pSelect = pSelect->pPrior;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x5260e
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %ebx
movq (%r14), %rsi
movq %r15, %rdi
callq 0x526a4
testl %eax, %eax
jne 0x52610
movq 0x28(%r14), %rsi
movq %r15, %rdi
callq 0x51f80
testl %eax, %eax
jne 0x52610
movq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x52618
testl %eax, %eax
jne 0x52610
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x526a4
testl %eax, %eax
jne 0x52610
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x52618
testl %eax, %eax
jne 0x52610
movq 0x48(%r14), %rsi
movq %r15, %rdi
callq 0x526a4
testl %eax, %eax
jne 0x52610
movq 0x68(%r14), %rsi
movq %r15, %rdi
callq 0x52618
testl %eax, %eax
jne 0x52610
movq 0x70(%r14), %rsi
movq %r15, %rdi
callq 0x52618
testl %eax, %eax
jne 0x52610
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x52582
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3FixExpr
SQLITE_PRIVATE int sqlite3FixExpr(
  DbFixer *pFix,     /* Context of the fixation */
  Expr *pExpr        /* The expression to be fixed to one database */
){
  while( pExpr ){
    if( pExpr->op==TK_VARIABLE ){
      if( pFix->pParse->db->init.busy ){
        pExpr->op = TK_NULL;
      }else{
        sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
        return 1;
      }
    }
    if( ExprHasProperty(pExpr, EP_TokenOnly) ) break;
    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
      if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
    }else{
      if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
    }
    if( sqlite3FixExpr(pFix, pExpr->pRight) ){
      return 1;
    }
    pExpr = pExpr->pLeft;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x5269c
movq %rsi, %r15
movq %rdi, %r14
cmpb $-0x7a, (%r15)
jne 0x52643
movq (%r14), %rdi
movq (%rdi), %rax
cmpb $0x0, 0x99(%rax)
je 0x52685
movb $0x63, (%r15)
movl 0x4(%r15), %eax
btl $0xe, %eax
jb 0x5269c
btl $0xb, %eax
movq 0x20(%r15), %rsi
movq %r14, %rdi
jb 0x52661
callq 0x526a4
jmp 0x52666
callq 0x52569
testl %eax, %eax
jne 0x52697
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x52618
testl %eax, %eax
jne 0x52697
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x5262a
jmp 0x5269c
movq 0x20(%r14), %rdx
leaq 0x20fc7(%rip), %rsi     # 0x73657
xorl %eax, %eax
callq 0x11db0
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3UniqueConstraint
SQLITE_PRIVATE void sqlite3UniqueConstraint(
  Parse *pParse,    /* Parsing context */
  int onError,      /* Constraint type */
  Index *pIdx       /* The index that triggers the constraint */
){
  char *zErr;
  int j;
  StrAccum errMsg;
  Table *pTab = pIdx->pTable;

  sqlite3StrAccumInit(&errMsg, 0, 0, 200);
  errMsg.db = pParse->db;
  for(j=0; j<pIdx->nKeyCol; j++){
    char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
    if( j ) sqlite3StrAccumAppend(&errMsg, ", ", 2);
    sqlite3StrAccumAppend(&errMsg, pTab->zName, -1);
    sqlite3StrAccumAppend(&errMsg, ".", 1);
    sqlite3StrAccumAppend(&errMsg, zCol, -1);
  }
  zErr = sqlite3StrAccumFinish(&errMsg);
  sqlite3HaltConstraint(pParse, 
    (pIdx->autoIndex==2)?SQLITE_CONSTRAINT_PRIMARYKEY:SQLITE_CONSTRAINT_UNIQUE,
    onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movl %esi, 0x4(%rsp)
movq 0x18(%rdx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
movl $0xc8, 0x30(%rsp)
movw $0x1, 0x34(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
cmpw $0x0, 0x5e(%rdx)
je 0x529e5
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
leaq 0x1a742(%rip), %r13     # 0x6d0b8
movq 0x8(%r14), %rax
movq 0x8(%r15), %rcx
movswq (%rcx,%rbp,2), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rbx
testq %rbp, %rbp
je 0x529a8
movq %r12, %rdi
leaq 0x20cd1(%rip), %rsi     # 0x7366f
movl $0x2, %edx
callq 0x18855
movq (%r14), %rsi
movq %r12, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x18855
movq %r12, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x18855
movq %r12, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x18855
incq %rbp
movzwl 0x5e(%r15), %eax
cmpq %rax, %rbp
jb 0x52976
leaq 0x10(%rsp), %rdi
callq 0xb875
movb 0x63(%r15), %cl
andb $0x3, %cl
xorl %esi, %esi
cmpb $0x2, %cl
setne %sil
shll $0x9, %esi
addl $0x613, %esi            # imm = 0x613
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
movq %rax, %rcx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0x2, %r9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b546
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]flappy/sqlite3.c
// Function: sqlite3IndexAffinityStr
SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){
  if( !pIdx->zColAff ){
    /* The first time a column affinity string for a particular index is
    ** required, it is allocated and populated here. It is then stored as
    ** a member of the Index structure for subsequent use.
    **
    ** The column affinity string will eventually be deleted by
    ** sqliteDeleteIndex() when the Index structure itself is cleaned
    ** up.
    */
    int n;
    Table *pTab = pIdx->pTable;
    sqlite3 *db = sqlite3VdbeDb(v);
    pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
    if( !pIdx->zColAff ){
      db->mallocFailed = 1;
      return 0;
    }
    for(n=0; n<pIdx->nColumn; n++){
      i16 x = pIdx->aiColumn[n];
      pIdx->zColAff[n] = x<0 ? SQLITE_AFF_INTEGER : pTab->aCol[x].affinity;
    }
    pIdx->zColAff[n] = 0;
  }
 
  return pIdx->zColAff;
}

// Assembly:
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x52a3d
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %r14
movq (%rdi), %r15
movzwl 0x60(%rsi), %edi
incl %edi
callq 0xa44e
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x52aa4
cmpw $0x0, 0x60(%rbx)
je 0x52aad
xorl %ecx, %ecx
movq 0x8(%rbx), %rax
movswq (%rax,%rcx,2), %rax
testq %rax, %rax
js 0x52a89
movq 0x8(%r14), %rdx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movb 0x29(%rdx,%rax), %al
jmp 0x52a8b
movb $0x64, %al
movq 0x20(%rbx), %rdx
movb %al, (%rdx,%rcx)
incq %rcx
movzwl 0x60(%rbx), %eax
cmpq %rax, %rcx
jb 0x52a69
movq 0x20(%rbx), %rax
jmp 0x52aaf
movb $0x1, 0x50(%r15)
xorl %eax, %eax
jmp 0x52ab7
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq 0x20(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq