LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: explainSimpleCount
static void explainSimpleCount(
  Parse *pParse,                  /* Parse context */
  Table *pTab,                    /* Table being queried */
  Index *pIdx                     /* Index used to optimize scan, or NULL */
){
  if( pParse->explain==2 ){
    int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
    sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s",
        pTab->zName,
        bCover ? " USING COVERING INDEX " : "",
        bCover ? pIdx->zName : ""
    );
  }
}

// Assembly:
cmpb $0x2, 0x11b(%rdi)
jne 0x2db8e2
testq %rdx, %rdx
je 0x2db8e3
movb $0x1, %al
testb $-0x80, 0x40(%rsi)
je 0x2db8e5
movzwl 0x63(%rdx), %eax
andl $0x3, %eax
cmpw $0x2, %ax
setne %al
jmp 0x2db8e5
retq
xorl %eax, %eax
movq (%rsi), %rcx
leaq 0x106a84(%rip), %r8     # 0x3e2373
leaq 0xf7f9a(%rip), %r9      # 0x3d3890
testb %al, %al
cmoveq %r9, %r8
je 0x2db901
movq (%rdx), %r9
leaq 0x106a59(%rip), %rdx    # 0x3e2361
xorl %esi, %esi
xorl %eax, %eax
jmp 0x2cae5e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprListAppendList
static ExprList *exprListAppendList(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to append. Might be NULL */
  ExprList *pAppend,      /* List of values to append. Might be NULL */
  int bIntToNull
){
  if( pAppend ){
    int i;
    int nInit = pList ? pList->nExpr : 0;
    for(i=0; i<pAppend->nExpr; i++){
      Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
      assert( pDup==0 || !ExprHasProperty(pDup, EP_MemToken) );
      if( bIntToNull && pDup ){
        int iDummy;
        Expr *pSub;
        for(pSub=pDup; ExprHasProperty(pSub, EP_Skip); pSub=pSub->pLeft){
          assert( pSub );
        }
        if( sqlite3ExprIsInteger(pSub, &iDummy) ){
          pSub->op = TK_NULL;
          pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
          pSub->u.zToken = 0;
        }
      }
      pList = sqlite3ExprListAppend(pParse, pList, pDup);
      if( pList ) pList->a[nInit+i].sortFlags = pAppend->a[i].sortFlags;
    }
  }
  return pList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
testq %rdx, %rdx
je 0x2dc063
movl %ecx, %r13d
movq %rdx, %rbp
testq %rbx, %rbx
je 0x2dbf7e
movslq (%rbx), %rax
movq %rax, (%rsp)
jmp 0x2dbf86
movq $0x0, (%rsp)
cmpl $0x0, (%rbp)
jle 0x2dc063
leaq 0x8(%rbp), %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movq %rbp, 0x18(%rsp)
leaq (%r14,%r14,2), %r15
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x2dbfc9
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
movq %rax, %r12
jmp 0x2dbfcc
xorl %r12d, %r12d
testl %r13d, %r13d
je 0x2dc020
testq %r12, %r12
je 0x2dc020
movl %r13d, %ebp
testb $0x10, 0x5(%r12)
movq %r12, %r13
je 0x2dbff2
movq %r12, %r13
movq 0x10(%r13), %r13
testb $0x10, 0x5(%r13)
jne 0x2dbfe7
movq %r13, %rdi
leaq 0x24(%rsp), %rsi
callq 0x2d2e59
testl %eax, %eax
je 0x2dc018
movb $0x77, (%r13)
andl $0xcffffbff, 0x4(%r13)  # imm = 0xCFFFFBFF
movq $0x0, 0x8(%r13)
movl %ebp, %r13d
movq 0x18(%rsp), %rbp
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2bb1a3
movq %rax, %rbx
testq %rax, %rax
je 0x2dc053
movq 0x8(%rsp), %rax
leaq (%rax,%r15,8), %rax
movb 0x10(%rax), %al
movq (%rsp), %rcx
addq %r14, %rcx
leaq (%rcx,%rcx,2), %rcx
movb %al, 0x18(%rbx,%rcx,8)
incq %r14
movslq (%rbp), %rax
cmpq %rax, %r14
jl 0x2dbfa1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowExtraAggFuncDepth
static int sqlite3WindowExtraAggFuncDepth(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_AGG_FUNCTION
   && pExpr->op2>=pWalker->walkerDepth
  ){
    pExpr->op2++;
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x5b, (%rsi)
jne 0x2dc088
movzbl 0x2(%rsi), %eax
cmpl %eax, 0x20(%rdi)
jg 0x2dc088
incb %al
movb %al, 0x2(%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: agginfoPersistExprCb
static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
  if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))
   && pExpr->pAggInfo!=0
  ){
    AggInfo *pAggInfo = pExpr->pAggInfo;
    int iAgg = pExpr->iAgg;
    Parse *pParse = pWalker->pParse;
    sqlite3 *db = pParse->db;
    assert( pExpr->op==TK_AGG_COLUMN || pExpr->op==TK_AGG_FUNCTION );
    if( pExpr->op==TK_AGG_COLUMN ){
      assert( iAgg>=0 && iAgg<pAggInfo->nColumn );
      if( pAggInfo->aCol[iAgg].pCExpr==pExpr ){
        pExpr = sqlite3ExprDup(db, pExpr, 0);
        if( pExpr ){
          pAggInfo->aCol[iAgg].pCExpr = pExpr;
          pParse->pConstExpr =
             sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
        }
      }
    }else{
      assert( iAgg>=0 && iAgg<pAggInfo->nFunc );
      if( pAggInfo->aFunc[iAgg].pFExpr==pExpr ){
        pExpr = sqlite3ExprDup(db, pExpr, 0);
        if( pExpr ){
          pAggInfo->aFunc[iAgg].pFExpr = pExpr;
          pParse->pConstExpr =
             sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
        }
      }
    }
  }
  return WRC_Continue;
}

// Assembly:
testb $0x60, 0x5(%rsi)
jne 0x2dc121
pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rsi), %r14
testq %r14, %r14
je 0x2dc11c
movswq 0x32(%rsi), %r15
movq (%rdi), %rbx
movq (%rbx), %rdi
cmpb $-0x5a, (%rsi)
jne 0x2dc0e5
movq 0x20(%r14), %rax
shlq $0x5, %r15
cmpq %rsi, 0x8(%rax,%r15)
jne 0x2dc11c
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
testq %rax, %rax
je 0x2dc11c
movq 0x20(%r14), %rcx
movq %rax, 0x8(%rcx,%r15)
jmp 0x2dc109
movq 0x30(%r14), %rax
leaq (%r15,%r15,2), %r15
cmpq %rsi, (%rax,%r15,8)
jne 0x2dc11c
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
testq %rax, %rax
je 0x2dc11c
movq 0x30(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x58(%rbx), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2bb1a3
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: selectWindowRewriteSelectCb
static int selectWindowRewriteSelectCb(Walker *pWalker, Select *pSelect){
  struct WindowRewrite *p = pWalker->u.pRewrite;
  Select *pSave = p->pSubSelect;
  if( pSave==pSelect ){
    return WRC_Continue;
  }else{
    p->pSubSelect = pSelect;
    sqlite3WalkSelect(pWalker, pSelect);
    p->pSubSelect = pSave;
  }
  return WRC_Prune;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
movq 0x20(%rbx), %r14
cmpq %rsi, %r14
je 0x2dc31a
movq %rsi, 0x20(%rbx)
callq 0x2ca2ea
movq %r14, 0x20(%rbx)
movl $0x1, %eax
jmp 0x2dc31c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: substSelect
static void substSelect(
  SubstContext *pSubst, /* Description of the substitution */
  Select *p,            /* SELECT statement in which to make substitutions */
  int doPrior           /* Do substitutes on p->pPrior too */
){
  SrcList *pSrc;
  struct SrcList_item *pItem;
  int i;
  if( !p ) return;
  do{
    substExprList(pSubst, p->pEList);
    substExprList(pSubst, p->pGroupBy);
    substExprList(pSubst, p->pOrderBy);
    p->pHaving = substExpr(pSubst, p->pHaving);
    p->pWhere = substExpr(pSubst, p->pWhere);
    pSrc = p->pSrc;
    assert( pSrc!=0 );
    for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
      substSelect(pSubst, pItem->pSelect, 1);
      if( pItem->fg.isTabFunc ){
        substExprList(pSubst, pItem->u1.pFuncArg);
      }
    }
  }while( doPrior && (p = p->pPrior)!=0 );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
testq %rsi, %rsi
je 0x2dc5b8
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x2dc49b
cmpl $0x0, (%r12)
jle 0x2dc49b
leaq 0x8(%r12), %r13
xorl %ebx, %ebx
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2dc615
movq %rax, (%r13)
incq %rbx
movslq (%r12), %rax
addq $0x18, %r13
cmpq %rax, %rbx
jl 0x2dc47b
movq 0x38(%r14), %r12
testq %r12, %r12
je 0x2dc4d2
cmpl $0x0, (%r12)
jle 0x2dc4d2
leaq 0x8(%r12), %r13
xorl %ebx, %ebx
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2dc615
movq %rax, (%r13)
incq %rbx
movslq (%r12), %rax
addq $0x18, %r13
cmpq %rax, %rbx
jl 0x2dc4b2
movq 0x48(%r14), %r12
testq %r12, %r12
je 0x2dc509
cmpl $0x0, (%r12)
jle 0x2dc509
leaq 0x8(%r12), %r13
xorl %ebx, %ebx
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2dc615
movq %rax, (%r13)
incq %rbx
movslq (%r12), %rax
addq $0x18, %r13
cmpq %rax, %rbx
jl 0x2dc4e9
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x2dc615
movq %rax, 0x40(%r14)
movq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x2dc615
movq %rax, 0x30(%r14)
movq %r14, 0x10(%rsp)
movq 0x28(%r14), %r12
movl (%r12), %r13d
testl %r13d, %r13d
jle 0x2dc59f
addq $0x8, %r12
movq 0x28(%r12), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x2dc443
testb $0x4, 0x3d(%r12)
je 0x2dc58e
movq 0x60(%r12), %rbp
testq %rbp, %rbp
je 0x2dc58e
cmpl $0x0, (%rbp)
jle 0x2dc58e
leaq 0x8(%rbp), %rbx
xorl %r14d, %r14d
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x2dc615
movq %rax, (%rbx)
incq %r14
movslq (%rbp), %rax
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x2dc570
leal -0x1(%r13), %eax
addq $0x70, %r12
cmpl $0x1, %r13d
movl %eax, %r13d
jg 0x2dc53f
cmpl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %r14
je 0x2dc5b8
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x2dc464
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: recomputeColumnsUsed
static void recomputeColumnsUsed(
  Select *pSelect,                 /* The complete SELECT statement */
  struct SrcList_item *pSrcItem    /* Which FROM clause item to recompute */
){
  Walker w;
  if( NEVER(pSrcItem->pTab==0) ) return;
  memset(&w, 0, sizeof(w));
  w.xExprCallback = recomputeColumnsUsedExpr;
  w.xSelectCallback = sqlite3SelectWalkNoop;
  w.u.pSrcItem = pSrcItem;
  pSrcItem->colUsed = 0;
  sqlite3WalkSelect(&w, pSelect);
}

// Assembly:
cmpq $0x0, 0x20(%rsi)
je 0x2dc614
subq $0x38, %rsp
movq %rdi, %rax
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
leaq 0x2f5(%rip), %rcx       # 0x2dc8e2
movq %rcx, 0x8(%rdi)
leaq -0x9894(%rip), %rcx     # 0x2d2d64
movq %rcx, 0x10(%rdi)
movq %rsi, 0x28(%rdi)
movq $0x0, 0x58(%rsi)
movq %rax, %rsi
callq 0x2ca2ea
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: recomputeColumnsUsedExpr
static int recomputeColumnsUsedExpr(Walker *pWalker, Expr *pExpr){
  struct SrcList_item *pItem;
  if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
  pItem = pWalker->u.pSrcItem;
  if( pItem->iCursor!=pExpr->iTable ) return WRC_Continue;
  if( pExpr->iColumn<0 ) return WRC_Continue;
  pItem->colUsed |= sqlite3ExprColUsed(pExpr);
  return WRC_Continue;
}

// Assembly:
cmpb $-0x5c, (%rsi)
jne 0x2dc908
pushq %rbx
movq 0x28(%rdi), %rbx
movl 0x40(%rbx), %eax
cmpl 0x2c(%rsi), %eax
jne 0x2dc907
cmpw $0x0, 0x30(%rsi)
js 0x2dc907
movq %rsi, %rdi
callq 0x2d0302
orq %rax, 0x58(%rbx)
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: multiSelectCollSeq
static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
  CollSeq *pRet;
  if( p->pPrior ){
    pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
  }else{
    pRet = 0;
  }
  assert( iCol>=0 );
  /* iCol must be less than p->pEList->nExpr.  Otherwise an error would
  ** have been thrown during name resolution and we would not have gotten
  ** this far */
  if( pRet==0 && ALWAYS(iCol<p->pEList->nExpr) ){
    pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
  }
  return pRet;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0x2dc983
movq %rbx, %rdi
movl %ebp, %edx
callq 0x2dc962
jmp 0x2dc985
xorl %eax, %eax
testq %rax, %rax
jne 0x2dc9ac
movq 0x20(%r14), %rax
cmpl %ebp, (%rax)
jle 0x2dc9aa
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2b32a0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: multiSelectOrderByKeyInfo
static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
  ExprList *pOrderBy = p->pOrderBy;
  int nOrderBy = p->pOrderBy->nExpr;
  sqlite3 *db = pParse->db;
  KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
  if( pRet ){
    int i;
    for(i=0; i<nOrderBy; i++){
      struct ExprList_item *pItem = &pOrderBy->a[i];
      Expr *pTerm = pItem->pExpr;
      CollSeq *pColl;

      if( pTerm->flags & EP_Collate ){
        pColl = sqlite3ExprCollSeq(pParse, pTerm);
      }else{
        pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
        if( pColl==0 ) pColl = db->pDfltColl;
        pOrderBy->a[i].pExpr =
          sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
      }
      assert( sqlite3KeyInfoIsWriteable(pRet) );
      pRet->aColl[i] = pColl;
      pRet->aSortFlags[i] = pOrderBy->a[i].sortFlags;
    }
  }

  return pRet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x48(%rsi), %r15
movslq (%r15), %rax
testq %rax, %rax
setle %bl
movq (%rdi), %rdi
movq %rax, 0x10(%rsp)
leal 0x1(%rax), %esi
movq %rdi, (%rsp)
movl $0x1, %edx
callq 0x2c6339
movq %rax, %r12
testq %rax, %rax
sete %al
orb %bl, %al
jne 0x2dca6f
addq $0x8, %r15
xorl %ebx, %ebx
movq (%r15), %r13
testb $0x1, 0x5(%r13)
jne 0x2dca42
movzwl 0x14(%r15), %edx
decl %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x2dc962
movq %rax, %rbp
testq %rax, %rax
jne 0x2dca2e
movq (%rsp), %rax
movq 0x10(%rax), %rbp
movq (%rbp), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2d0359
movq %rax, (%r15)
jmp 0x2dca50
movq %r14, %rdi
movq %r13, %rsi
callq 0x2b32a0
movq %rax, %rbp
movq %rbp, 0x20(%r12,%rbx,8)
movb 0x10(%r15), %al
movq 0x18(%r12), %rcx
movb %al, (%rcx,%rbx)
incq %rbx
addq $0x18, %r15
cmpq %rbx, 0x10(%rsp)
jne 0x2dca00
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: findConstInWhere
static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
  Expr *pRight, *pLeft;
  if( pExpr==0 ) return;
  if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
  if( pExpr->op==TK_AND ){
    findConstInWhere(pConst, pExpr->pRight);
    findConstInWhere(pConst, pExpr->pLeft);
    return;
  }
  if( pExpr->op!=TK_EQ ) return;
  pRight = pExpr->pRight;
  pLeft = pExpr->pLeft;
  assert( pRight!=0 );
  assert( pLeft!=0 );
  if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){
    constInsert(pConst,pRight,pLeft,pExpr);
  }
  if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){
    constInsert(pConst,pLeft,pRight,pExpr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0x2dcfd4
testb $0x1, 0x4(%rbx)
jne 0x2dcfd4
movzbl (%rbx), %eax
cmpl $0x2c, %eax
jne 0x2dcf21
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2dcee0
movq 0x10(%rbx), %rbx
jmp 0x2dcef4
cmpl $0x35, %eax
jne 0x2dcfd4
movq 0x10(%rbx), %r12
movq 0x18(%rbx), %r15
cmpb $-0x5c, (%r15)
leaq -0x12e1a(%rip), %rbp    # 0x2ca123
leaq -0x12d3f(%rip), %r13    # 0x2ca205
jne 0x2dcf8a
movw $0x1, 0x2c(%rsp)
movq %rbp, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
testq %r12, %r12
je 0x2dcf71
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2ca211
cmpw $0x0, 0x2c(%rsp)
je 0x2dcf8a
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2dd07e
cmpb $-0x5c, (%r12)
jne 0x2dcfd4
movq %r13, %rax
leaq 0x8(%rsp), %r13
movw $0x1, 0x24(%r13)
movq %rbp, 0x8(%r13)
movq %rax, 0x10(%r13)
movl $0x0, 0x28(%r13)
movq %r13, %rdi
movq %r15, %rsi
callq 0x2ca211
cmpw $0x0, 0x24(%r13)
je 0x2dcfd4
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2dd07e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: propagateConstantExprRewrite
static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
  int i;
  WhereConst *pConst;
  if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
  if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
    testcase( ExprHasProperty(pExpr, EP_FixedCol) );
    testcase( ExprHasProperty(pExpr, EP_FromJoin) );
    return WRC_Continue;
  }
  pConst = pWalker->u.pConst;
  for(i=0; i<pConst->nConst; i++){
    Expr *pColumn = pConst->apExpr[i*2];
    if( pColumn==pExpr ) continue;
    if( pColumn->iTable!=pExpr->iTable ) continue;
    if( pColumn->iColumn!=pExpr->iColumn ) continue;
    /* A match is found.  Add the EP_FixedCol property */
    pConst->nChng++;
    ExprClearProperty(pExpr, EP_Leaf);
    ExprSetProperty(pExpr, EP_FixedCol);
    assert( pExpr->pLeft==0 );
    pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
    break;
  }
  return WRC_Prune;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $-0x5c, (%rsi)
jne 0x2dd074
movq %rsi, %r14
testb $0x9, 0x4(%rsi)
jne 0x2dd074
movq 0x28(%rdi), %rax
movslq 0x8(%rax), %rdx
movl $0x1, %ebx
testq %rdx, %rdx
jle 0x2dd074
movq 0x10(%rax), %rcx
shlq $0x4, %rdx
xorl %esi, %esi
movq (%rcx,%rsi), %rdi
cmpq %r14, %rdi
je 0x2dd035
movl 0x2c(%rdi), %r8d
cmpl 0x2c(%r14), %r8d
jne 0x2dd035
movzwl 0x30(%rdi), %edi
cmpw 0x30(%r14), %di
je 0x2dd040
addq $0x10, %rsi
cmpq %rsi, %rdx
jne 0x2dd017
jmp 0x2dd074
incl 0xc(%rax)
movl $0xff7ffff7, %edx       # imm = 0xFF7FFFF7
andl 0x4(%r14), %edx
orl $0x8, %edx
movl %edx, 0x4(%r14)
movq 0x8(%rcx,%rsi), %rsi
testq %rsi, %rsi
je 0x2dd06e
movq (%rax), %rax
movq (%rax), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
jmp 0x2dd070
xorl %eax, %eax
movq %rax, 0x10(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: constInsert
static void constInsert(
  WhereConst *pConst,  /* The WhereConst into which we are inserting */
  Expr *pColumn,       /* The COLUMN part of the constraint */
  Expr *pValue,        /* The VALUE part of the constraint */
  Expr *pExpr          /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
){
  int i;
  assert( pColumn->op==TK_COLUMN );
  assert( sqlite3ExprIsConstant(pValue) );

  if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
  if( sqlite3ExprAffinity(pValue)!=0 ) return;
  if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
    return;
  }

  /* 2018-10-25 ticket [cf5ed20f]
  ** Make sure the same pColumn is not inserted more than once */
  for(i=0; i<pConst->nConst; i++){
    const Expr *pE2 = pConst->apExpr[i*2];
    assert( pE2->op==TK_COLUMN );
    if( pE2->iTable==pColumn->iTable
     && pE2->iColumn==pColumn->iColumn
    ){
      return;  /* Already present.  Return without doing anything. */
    }
  }

  pConst->nConst++;
  pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
                         pConst->nConst*2*sizeof(Expr*));
  if( pConst->apExpr==0 ){
    pConst->nConst = 0;
  }else{
    pConst->apExpr[pConst->nConst*2-2] = pColumn;
    pConst->apExpr[pConst->nConst*2-1] = pValue;
  }
}

// Assembly:
testb $0x8, 0x4(%rsi)
jne 0x2dd0af
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2ca042
testb %al, %al
je 0x2dd0b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq %r12, %rsi
callq 0x287c50
testq %rax, %rax
je 0x2dd0cd
leaq 0x94(%rip), %rcx        # 0x2dd15b
cmpq %rcx, 0x18(%rax)
jne 0x2dd0a4
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x2dd106
movq 0x10(%r14), %rcx
movl 0x2c(%r15), %edx
movq %rax, %rsi
shlq $0x4, %rsi
xorl %edi, %edi
movq (%rcx,%rdi), %r8
cmpl %edx, 0x2c(%r8)
jne 0x2dd0fd
movzwl 0x30(%r8), %r8d
cmpw 0x30(%r15), %r8w
je 0x2dd0a4
addq $0x10, %rdi
cmpq %rdi, %rsi
jne 0x2dd0e7
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
movq (%r14), %rcx
movq 0x10(%r14), %rsi
movq (%rcx), %rdi
leal 0x2(,%rax,2), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x29b6a6
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x2dd14e
movslq 0x8(%r14), %rcx
shlq $0x4, %rcx
movq %r15, -0x10(%rax,%rcx)
movq 0x10(%r14), %rax
movq %rbx, -0x8(%rax,%rcx)
jmp 0x2dd0a4
movl $0x0, 0x8(%r14)
jmp 0x2dd0a4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: heightOfSelect
static void heightOfSelect(Select *pSelect, int *pnHeight){
  Select *p;
  for(p=pSelect; p; p=p->pPrior){
    heightOfExpr(p->pWhere, pnHeight);
    heightOfExpr(p->pHaving, pnHeight);
    heightOfExpr(p->pLimit, pnHeight);
    heightOfExprList(p->pEList, pnHeight);
    heightOfExprList(p->pGroupBy, pnHeight);
    heightOfExprList(p->pOrderBy, pnHeight);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2dd1f1
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x2dd199
movl 0x28(%rax), %eax
cmpl (%rbx), %eax
jle 0x2dd199
movl %eax, (%rbx)
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x2dd1ab
movl 0x28(%rax), %eax
cmpl (%rbx), %eax
jle 0x2dd1ab
movl %eax, (%rbx)
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x2dd1bd
movl 0x28(%rax), %eax
cmpl (%rbx), %eax
jle 0x2dd1bd
movl %eax, (%rbx)
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd1f2
movq 0x38(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd1f2
movq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0x2dd1f2
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x2dd187
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WhereSplit
SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
  Expr *pE2 = sqlite3ExprSkipCollateAndLikely(pExpr);
  pWC->op = op;
  if( pE2==0 ) return;
  if( pE2->op!=op ){
    whereClauseInsert(pWC, pExpr, 0);
  }else{
    sqlite3WhereSplit(pWC, pE2->pLeft, op);
    sqlite3WhereSplit(pWC, pE2->pRight, op);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movzbl %bl, %ebp
movq %rsi, %r15
testq %rsi, %rsi
je 0x2dd264
movq %rsi, %r15
movl 0x4(%r15), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2dd264
btl $0x12, %eax
jb 0x2dd254
addq $0x10, %r15
jmp 0x2dd25c
movq 0x20(%r15), %r15
addq $0x8, %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x2dd23d
movb %bl, 0x10(%r14)
testq %r15, %r15
je 0x2dd286
cmpb %bl, (%r15)
jne 0x2dd291
movq 0x10(%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x2dd223
movq 0x18(%r15), %rsi
jmp 0x2dd232
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2e0a80
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WhereExprListUsage
SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet *pMaskSet, ExprList *pList){
  int i;
  Bitmask mask = 0;
  if( pList ){
    for(i=0; i<pList->nExpr; i++){
      mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
    }
  }
  return mask;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x2ddb3c
movq %rsi, %rbx
cmpl $0x0, (%rsi)
jle 0x2ddb3c
movq %rdi, %r14
leaq 0x8(%rbx), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%r12), %rsi
testq %rsi, %rsi
je 0x2ddb26
movq %r14, %rdi
callq 0x2e2a4c
jmp 0x2ddb28
xorl %eax, %eax
orq %rax, %r15
incq %r13
movslq (%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x2ddb13
jmp 0x2ddb3f
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereInfoFree
static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
  int i;
  assert( pWInfo!=0 );
  for(i=0; i<pWInfo->nLevel; i++){
    WhereLevel *pLevel = &pWInfo->a[i];
    if( pLevel->pWLoop && (pLevel->pWLoop->wsFlags & WHERE_IN_ABLE) ){
      sqlite3DbFree(db, pLevel->u.in.aInLoop);
    }
  }
  sqlite3WhereClauseClear(&pWInfo->sWC);
  while( pWInfo->pLoops ){
    WhereLoop *p = pWInfo->pLoops;
    pWInfo->pLoops = p->pNextLoop;
    whereLoopDelete(db, p);
  }
  assert( pWInfo->pExprMods==0 );
  sqlite3DbFreeNN(db, pWInfo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x40(%rsi)
je 0x2e0a38
leaq 0x3e8(%rbx), %r15
xorl %r12d, %r12d
movq (%r15), %rax
testq %rax, %rax
je 0x2e0a28
testb $0x8, 0x29(%rax)
je 0x2e0a28
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x2e0a28
movq %r14, %rdi
callq 0x28c3e7
incq %r12
movzbl 0x40(%rbx), %eax
addq $0x60, %r15
cmpq %rax, %r12
jb 0x2e0a09
leaq 0x68(%rbx), %rdi
callq 0x2e756a
movq 0x50(%rbx), %r15
testq %r15, %r15
je 0x2e0a6a
movq 0x40(%r15), %rax
movq %rax, 0x50(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2e44c4
movq %r14, %rdi
movq %r15, %rsi
callq 0x28c3e7
jmp 0x2e0a41
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28c3e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereClauseInsert
static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
  WhereTerm *pTerm;
  int idx;
  testcase( wtFlags & TERM_VIRTUAL );
  if( pWC->nTerm>=pWC->nSlot ){
    WhereTerm *pOld = pWC->a;
    sqlite3 *db = pWC->pWInfo->pParse->db;
    pWC->a = sqlite3DbMallocRawNN(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
    if( pWC->a==0 ){
      if( wtFlags & TERM_DYNAMIC ){
        sqlite3ExprDelete(db, p);
      }
      pWC->a = pOld;
      return 0;
    }
    memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
    if( pOld!=pWC->aStatic ){
      sqlite3DbFree(db, pOld);
    }
    pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
  }
  pTerm = &pWC->a[idx = pWC->nTerm++];
  if( p && ExprHasProperty(p, EP_Unlikely) ){
    pTerm->truthProb = sqlite3LogEst(p->iTable) - 270;
  }else{
    pTerm->truthProb = 1;
  }
  pTerm->pExpr = sqlite3ExprSkipCollateAndLikely(p);
  pTerm->wtFlags = wtFlags;
  pTerm->pWC = pWC;
  pTerm->iParent = -1;
  memset(&pTerm->eOperator, 0,
         sizeof(WhereTerm) - offsetof(WhereTerm,eOperator));
  return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x18(%rdi), %rsi
cmpl %esi, 0x14(%rdi)
jl 0x2e0b5b
movq (%r14), %rax
movq 0x20(%r14), %rbp
movq (%rax), %rax
movq (%rax), %r13
shlq $0x7, %rsi
movq %r13, %rdi
callq 0x28c518
movq %rax, %r12
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x2e0b33
movslq 0x14(%r14), %rdx
shlq $0x6, %rdx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x17660
leaq 0x28(%r14), %rax
cmpq %rax, %rbp
sete %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
jne 0x2e0af7
movq %r13, %rdi
movq %rbp, %rsi
callq 0x28c3e7
movq 0x20(%r14), %rdi
testq %r13, %r13
je 0x2e0b24
cmpq %rdi, 0x1c0(%r13)
jbe 0x2e0b24
movl $0x80, %eax
cmpq %rdi, 0x1b0(%r13)
jbe 0x2e0b2a
cmpq %rdi, 0x1b8(%r13)
jbe 0x2e0bfc
callq *0x1e5b6e(%rip)         # 0x4c6698
sarl $0x6, %eax
movl %eax, 0x18(%r14)
jmp 0x2e0b52
testb $0x1, %bl
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x2e0b4e
movq %r13, %rdi
movq %r15, %rsi
callq 0x2afd54
movq %rbp, 0x20(%r14)
testq %r12, %r12
je 0x2e0bf7
movslq 0x14(%r14), %r12
leal 0x1(%r12), %eax
movl %eax, 0x14(%r14)
movq %r12, %r13
shlq $0x6, %r13
addq 0x20(%r14), %r13
testq %r15, %r15
je 0x2e0bbf
movw $0x1, %ax
testb $0x4, 0x6(%r15)
je 0x2e0b91
movslq 0x2c(%r15), %rdi
callq 0x2a680d
addl $0xfffffef2, %eax       # imm = 0xFFFFFEF2
movw %ax, 0x10(%r13)
testq %r15, %r15
je 0x2e0bc6
movl 0x4(%r15), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2e0bc6
btl $0x12, %eax
jb 0x2e0bb2
addq $0x10, %r15
jmp 0x2e0bba
movq 0x20(%r15), %r15
addq $0x8, %r15
movq (%r15), %r15
jmp 0x2e0b96
movw $0x1, 0x10(%r13)
movq %r15, (%r13)
movw %bx, 0x12(%r13)
movq %r14, 0x8(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%r13)
movups %xmm0, 0x24(%r13)
movups %xmm0, 0x30(%r13)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0x2e0be5
movzwl 0x176(%r13), %eax
jmp 0x2e0b2a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: termIsEquivalence
static int termIsEquivalence(Parse *pParse, Expr *pExpr){
  char aff1, aff2;
  CollSeq *pColl;
  if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0;
  if( pExpr->op!=TK_EQ && pExpr->op!=TK_IS ) return 0;
  if( ExprHasProperty(pExpr, EP_FromJoin) ) return 0;
  aff1 = sqlite3ExprAffinity(pExpr->pLeft);
  aff2 = sqlite3ExprAffinity(pExpr->pRight);
  if( aff1!=aff2
   && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2))
  ){
    return 0;
  }
  pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
  if( sqlite3IsBinary(pColl) ) return 1;
  return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
xorl %ebp, %ebp
testb $-0x80, 0x5c(%rax)
jne 0x2e2dd9
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x35, %eax
je 0x2e2d0c
cmpl $0x2d, %eax
jne 0x2e2dd9
testb $0x1, 0x4(%r14)
jne 0x2e2dd9
movq 0x10(%r14), %rdi
callq 0x2ca042
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x2ca042
cmpb %al, %r15b
je 0x2e2d45
cmpb $0x43, %r15b
setl %cl
cmpb $0x43, %al
setl %al
orb %cl, %al
jne 0x2e2dd9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x287c50
movl $0x1, %ebp
testq %rax, %rax
je 0x2e2dd9
leaq -0x5c06(%rip), %rcx     # 0x2dd15b
cmpq %rcx, 0x18(%rax)
je 0x2e2dd9
movq 0x10(%r14), %rsi
movq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0x2b32a0
movq %rax, %r14
testq %rax, %rax
jne 0x2e2d86
movq (%rbx), %rax
movq 0x10(%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b32a0
testq %rax, %rax
jne 0x2e2d9d
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%r14), %rcx
movq (%rax), %rax
xorl %edx, %edx
leaq 0xf7cb4(%rip), %rsi     # 0x3daa60
movzbl (%rcx,%rdx), %edi
movzbl (%rax,%rdx), %r8d
cmpb %r8b, %dil
jne 0x2e2dc1
testq %rdi, %rdi
jne 0x2e2dcb
jmp 0x2e2dd0
movb (%rdi,%rsi), %r9b
cmpb (%r8,%rsi), %r9b
jne 0x2e2dd0
incq %rdx
jmp 0x2e2dac
xorl %ebp, %ebp
cmpb %r8b, %dil
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprForVectorField
SQLITE_PRIVATE Expr *sqlite3ExprForVectorField(
  Parse *pParse,       /* Parsing context */
  Expr *pVector,       /* The vector.  List of expressions or a sub-SELECT */
  int iField           /* Which column of the vector to return */
){
  Expr *pRet;
  if( pVector->op==TK_SELECT ){
    assert( pVector->flags & EP_xIsSelect );
    /* The TK_SELECT_COLUMN Expr node:
    **
    ** pLeft:           pVector containing TK_SELECT.  Not deleted.
    ** pRight:          not used.  But recursively deleted.
    ** iColumn:         Index of a column in pVector
    ** iTable:          0 or the number of columns on the LHS of an assignment
    ** pLeft->iTable:   First in an array of register holding result, or 0
    **                  if the result is not yet computed.
    **
    ** sqlite3ExprDelete() specifically skips the recursive delete of
    ** pLeft on TK_SELECT_COLUMN nodes.  But pRight is followed, so pVector
    ** can be attached to pRight to cause this node to take ownership of
    ** pVector.  Typically there will be multiple TK_SELECT_COLUMN nodes
    ** with the same pLeft pointer to the pVector, but only one of them
    ** will own the pVector.
    */
    pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0);
    if( pRet ){
      pRet->iColumn = iField;
      pRet->pLeft = pVector;
    }
    assert( pRet==0 || pRet->iTable==0 );
  }else{
    if( pVector->op==TK_VECTOR ) pVector = pVector->x.pList->a[iField].pExpr;
    pRet = sqlite3ExprDup(pParse->db, pVector, 0);
    sqlite3RenameTokenRemap(pParse, pRet, pVector);
  }
  return pRet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movzbl (%rsi), %eax
cmpl $0xae, %eax
je 0x2e2e2c
cmpl $0x88, %eax
jne 0x2e2e3c
xorl %r14d, %r14d
movq %r15, %rdi
movl $0xaf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2b6fa0
testq %rax, %rax
je 0x2e2e72
movw %bp, 0x30(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %r14
jmp 0x2e2e72
movq 0x20(%rbx), %rax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rbx
testq %rbx, %rbx
je 0x2e2e55
movq (%r15), %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
movq %rax, %r14
jmp 0x2e2e58
xorl %r14d, %r14d
movq 0x1a0(%r15), %rax
testq %rax, %rax
je 0x2e2e72
cmpq %rbx, (%rax)
je 0x2e2e6f
movq 0x18(%rax), %rax
jmp 0x2e2e5f
movq %r14, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprMightBeIndexed2
static SQLITE_NOINLINE int exprMightBeIndexed2(
  SrcList *pFrom,        /* The FROM clause */
  Bitmask mPrereq,       /* Bitmask of FROM clause terms referenced by pExpr */
  int *aiCurCol,         /* Write the referenced table cursor and column here */
  Expr *pExpr            /* An operand of a comparison operator */
){
  Index *pIdx;
  int i;
  int iCur;
  for(i=0; mPrereq>1; i++, mPrereq>>=1){}
  iCur = pFrom->a[i].iCursor;
  for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
    if( pIdx->aColExpr==0 ) continue;
    for(i=0; i<pIdx->nKeyCol; i++){
      if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
      if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
        aiCurCol[0] = iCur;
        aiCurCol[1] = XN_EXPR;
        return 1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x2, %rsi
jb 0x2e2ead
movq %rsi, %rdx
shrq %rdx
incq %rcx
cmpq $0x3, %rsi
movq %rdx, %rsi
ja 0x2e2e9e
imulq $0x70, %rcx, %rcx
movq 0x28(%rdi,%rcx), %rdx
movq 0x10(%rdx), %r15
testq %r15, %r15
je 0x2e2f29
movl 0x48(%rdi,%rcx), %ebp
cmpq $0x0, 0x50(%r15)
je 0x2e2f0e
cmpw $0x0, 0x5e(%r15)
je 0x2e2f0e
movl $0x4, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rax
cmpw $-0x2, (%rax,%r13,2)
jne 0x2e2efd
movq 0x50(%r15), %rax
movq (%rax,%r12,2), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x2e2f38
testl %eax, %eax
je 0x2e2f1b
incq %r13
movzwl 0x5e(%r15), %eax
addq $0xc, %r12
cmpq %rax, %r13
jb 0x2e2edb
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x2e2ec3
xorl %eax, %eax
jmp 0x2e2f29
movl %ebp, (%rbx)
movl $0xfffffffe, 0x4(%rbx)  # imm = 0xFFFFFFFE
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCompareSkip
SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA, Expr *pB, int iTab){
  return sqlite3ExprCompare(0,
             sqlite3ExprSkipCollateAndLikely(pA),
             sqlite3ExprSkipCollateAndLikely(pB),
             iTab);
}

// Assembly:
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rsi
testq %rdi, %rdi
je 0x2e2f8e
movl 0x4(%rsi), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2e2f8e
btl $0x12, %eax
jb 0x2e2f5b
addq $0x10, %rsi
jmp 0x2e2f63
movq 0x20(%rsi), %rsi
addq $0x8, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x2e2f45
jmp 0x2e2f8e
movl 0x4(%rdx), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2e2f93
btl $0x12, %eax
jb 0x2e2f83
addq $0x10, %rdx
jmp 0x2e2f8b
movq 0x20(%rdx), %rdx
addq $0x8, %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
jne 0x2e2f6d
xorl %edi, %edi
jmp 0x2ca527
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WhereFindTerm
SQLITE_PRIVATE WhereTerm *sqlite3WhereFindTerm(
  WhereClause *pWC,     /* The WHERE clause to be searched */
  int iCur,             /* Cursor number of LHS */
  int iColumn,          /* Column number of LHS */
  Bitmask notReady,     /* RHS must not overlap with this mask */
  u32 op,               /* Mask of WO_xx values describing operator */
  Index *pIdx           /* Must be compatible with this index, if not NULL */
){
  WhereTerm *pResult = 0;
  WhereTerm *p;
  WhereScan scan;

  p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx);
  op &= WO_EQ|WO_IS;
  while( p ){
    if( (p->prereqRight & notReady)==0 ){
      if( p->prereqRight==0 && (p->eOperator&op)!=0 ){
        testcase( p->eOperator & WO_IS );
        return p;
      }
      if( pResult==0 ) pResult = p;
    }
    p = whereScanNext(&scan);
  }
  return pResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x2e302b
testq %rax, %rax
je 0x2e3014
andl $0x82, %ebx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq 0x30(%rax), %rcx
testq %r14, %rcx
jne 0x2e3005
testq %rcx, %rcx
jne 0x2e2ffe
movzwl 0x14(%rax), %ecx
testl %ecx, %ebx
jne 0x2e3026
testq %r15, %r15
cmoveq %rax, %r15
movq %r12, %rdi
callq 0x2e30f8
testq %rax, %rax
jne 0x2e2fe8
jmp 0x2e3017
xorl %r15d, %r15d
movq %r15, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x2e3017
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereScanInit
static WhereTerm *whereScanInit(
  WhereScan *pScan,       /* The WhereScan object being initialized */
  WhereClause *pWC,       /* The WHERE clause to be scanned */
  int iCur,               /* Cursor to scan for */
  int iColumn,            /* Column to scan for */
  u32 opMask,             /* Operator(s) to scan for */
  Index *pIdx             /* Must be compatible with this index */
){
  pScan->pOrigWC = pWC;
  pScan->pWC = pWC;
  pScan->pIdxExpr = 0;
  pScan->idxaff = 0;
  pScan->zCollName = 0;
  pScan->opMask = opMask;
  pScan->k = 0;
  pScan->aiCur[0] = iCur;
  pScan->nEquiv = 1;
  pScan->iEquiv = 1;
  if( pIdx ){
    int j = iColumn;
    iColumn = pIdx->aiColumn[j];
    if( iColumn==XN_EXPR ){
      pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
      pScan->zCollName = pIdx->azColl[j];
      pScan->aiColumn[0] = XN_EXPR;
      return whereScanInitIndexExpr(pScan);
    }else if( iColumn==pIdx->pTable->iPKey ){
      iColumn = XN_ROWID;
    }else if( iColumn>=0 ){
      pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity;
      pScan->zCollName = pIdx->azColl[j];
    }
  }else if( iColumn==XN_EXPR ){
    return 0;
  }
  pScan->aiColumn[0] = iColumn;
  return whereScanNext(pScan);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movb $0x0, 0x20(%rdi)
movl %r8d, 0x24(%rdi)
movl $0x0, 0x28(%rdi)
movl %edx, 0x2c(%rdi)
movw $0x101, 0x21(%rdi)      # imm = 0x101
testq %r9, %r9
je 0x2e309e
movq 0x8(%r9), %rdx
movslq %ecx, %rax
movswl (%rdx,%rax,2), %ebp
cmpl $-0x2, %ebp
jne 0x2e30a7
movq 0x50(%r9), %rcx
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %rcx
movq %rcx, 0x18(%rbx)
movq 0x40(%r9), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
movw $0xfffe, 0x58(%rbx)     # imm = 0xFFFE
movq %rbx, %rdi
callq 0x2e333c
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x2e30dc
cmpl $-0x2, %ecx
jne 0x2e30e9
xorl %eax, %eax
jmp 0x2e30e2
movq 0x18(%r9), %rcx
cmpw 0x44(%rcx), %bp
jne 0x2e30b8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x2e30dc
testw %bp, %bp
js 0x2e30da
movq 0x8(%rcx), %rcx
movl %ebp, %edx
shlq $0x5, %rdx
movb 0x19(%rcx,%rdx), %cl
movb %cl, 0x20(%rbx)
movq 0x40(%r9), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
movl %ebp, %ecx
cmpw $-0x2, %bp
jne 0x2e30e9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movw %cx, 0x58(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2e30f8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IndexAffinityOk
SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity){
  char aff = comparisonAffinity(pExpr);
  if( aff<SQLITE_AFF_TEXT ){
    return 1;
  }
  if( aff==SQLITE_AFF_TEXT ){
    return idx_affinity==SQLITE_AFF_TEXT;
  }
  return sqlite3IsNumericAffinity(idx_affinity);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x2ca042
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x2e3392
testb $0x8, 0x5(%r14)
jne 0x2e3386
testb %al, %al
movzbl %al, %ecx
movl $0x41, %eax
cmovnel %ecx, %eax
jmp 0x2e339a
movq 0x20(%r14), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %rdi
movsbl %al, %esi
callq 0x2ca0e4
movb $0x1, %cl
cmpb $0x42, %al
jl 0x2e33b0
jne 0x2e33aa
cmpb $0x42, %bl
sete %cl
jmp 0x2e33b0
cmpb $0x43, %bl
setge %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereLoopResize
static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){
  WhereTerm **paNew;
  if( p->nLSlot>=n ) return SQLITE_OK;
  n = (n+7)&~7;
  paNew = sqlite3DbMallocRawNN(db, sizeof(p->aLTerm[0])*n);
  if( paNew==0 ) return SQLITE_NOMEM_BKPT;
  memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot);
  if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFreeNN(db, p->aLTerm);
  p->aLTerm = paNew;
  p->nLSlot = n;
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movzwl 0x30(%rsi), %eax
xorl %ebx, %ebx
cmpl %edx, %eax
jge 0x2e457e
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
addl $0x7, %r14d
andl $-0x8, %r14d
leaq (,%r14,8), %rsi
callq 0x28c518
testq %rax, %rax
je 0x2e4579
movq %rax, %r13
movq 0x38(%r15), %rsi
movzwl 0x30(%r15), %edx
shll $0x3, %edx
movq %rax, %rdi
callq 0x17660
movq 0x38(%r15), %rsi
leaq 0x48(%r15), %rax
cmpq %rax, %rsi
je 0x2e456e
movq %r12, %rdi
callq 0x28c3e7
movq %r13, 0x38(%r15)
movw %r14w, 0x30(%r15)
jmp 0x2e457e
movl $0x7, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereLoopCheaperProperSubset
static int whereLoopCheaperProperSubset(
  const WhereLoop *pX,       /* First WhereLoop to compare */
  const WhereLoop *pY        /* Compare against this WhereLoop */
){
  int i, j;
  if( pX->nLTerm-pX->nSkip >= pY->nLTerm-pY->nSkip ){
    return 0; /* X is not a subset of Y */
  }
  if( pY->nSkip > pX->nSkip ) return 0;
  if( pX->rRun >= pY->rRun ){
    if( pX->rRun > pY->rRun ) return 0;    /* X costs more than Y */
    if( pX->nOut > pY->nOut ) return 0;    /* X costs more than Y */
  }
  for(i=pX->nLTerm-1; i>=0; i--){
    if( pX->aLTerm[i]==0 ) continue;
    for(j=pY->nLTerm-1; j>=0; j--){
      if( pY->aLTerm[j]==pX->aLTerm[i] ) break;
    }
    if( j<0 ) return 0;  /* X not a subset of Y since term X[i] not used by Y */
  }
  if( (pX->wsFlags&WHERE_IDX_ONLY)!=0
   && (pY->wsFlags&WHERE_IDX_ONLY)==0 ){
    return 0;  /* Constraint (5) */
  }
  return 1;  /* All conditions meet */
}

// Assembly:
movzwl 0x2e(%rdi), %edx
movzwl 0x2e(%rsi), %r8d
xorl %eax, %eax
cmpw %dx, %r8w
ja 0x2e4e59
movzwl 0x2c(%rdi), %ecx
movl %ecx, %r9d
subl %edx, %r9d
movzwl 0x2c(%rsi), %edx
movl %edx, %r10d
subl %r8d, %r10d
cmpl %r10d, %r9d
jge 0x2e4e59
movzwl 0x14(%rsi), %r8d
cmpw %r8w, 0x14(%rdi)
jge 0x2e4e4b
pushq %rbx
testq %rcx, %rcx
je 0x2e4e33
movq 0x38(%rdi), %r8
movq -0x8(%r8,%rcx,8), %r9
testq %r9, %r9
je 0x2e4e26
movq %rdx, %r11
xorl %eax, %eax
testq %r11, %r11
jle 0x2e4e1e
leaq -0x1(%r11), %r10
movq 0x38(%rsi), %rbx
cmpq %r9, -0x8(%rbx,%r11,8)
movq %r10, %r11
jne 0x2e4e00
incl %r10d
jmp 0x2e4e21
xorl %r10d, %r10d
testl %r10d, %r10d
jle 0x2e4e49
leaq -0x1(%rcx), %rax
cmpq $0x1, %rcx
movq %rax, %rcx
jg 0x2e4df3
testb $0x40, 0x28(%rdi)
je 0x2e4e44
testb $0x40, 0x28(%rsi)
movl $0x0, %eax
je 0x2e4e49
movl $0x1, %eax
popq %rbx
retq
jg 0x2e4e59
movzwl 0x16(%rdi), %r8d
cmpw 0x16(%rsi), %r8w
jle 0x2e4de9
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: termCanDriveIndex
static int termCanDriveIndex(
  WhereTerm *pTerm,              /* WHERE clause term to check */
  struct SrcList_item *pSrc,     /* Table we are trying to access */
  Bitmask notReady               /* Tables in outer loops of the join */
){
  char aff;
  if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
  if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
  if( (pSrc->fg.jointype & JT_LEFT)
   && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
   && (pTerm->eOperator & WO_IS)
  ){
    /* Cannot use an IS term from the WHERE clause as an index driver for
    ** the RHS of a LEFT JOIN. Such a term can only be used if it is from
    ** the ON clause.  */
    return 0;
  }
  if( (pTerm->prereqRight & notReady)!=0 ) return 0;
  if( pTerm->u.leftColumn<0 ) return 0;
  aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
  if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
  testcase( pTerm->pExpr->op==TK_IS );
  return 1;
}

// Assembly:
movl 0x1c(%rdi), %eax
cmpl 0x40(%rsi), %eax
jne 0x2e4f1b
movzwl 0x14(%rdi), %eax
testb $-0x7e, %al
je 0x2e4f1b
testb $0x8, 0x3c(%rsi)
jne 0x2e4f0c
testq %rdx, 0x30(%rdi)
jne 0x2e4f1b
movslq 0x28(%rdi), %rax
testq %rax, %rax
js 0x2e4f1b
movq 0x20(%rsi), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movsbl 0x19(%rcx,%rax), %esi
movq (%rdi), %rdi
jmp 0x2e3355
testb %al, %al
jns 0x2e4ee4
movq (%rdi), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
jne 0x2e4ee4
xorl %eax, %eax
retq