LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, 0x18(%rsp)
testq %rdx, %rdx
je 0x2d2871
movl %ecx, %r13d
movq %rdx, %rbp
testq %rbx, %rbx
je 0x2d278d
movslq (%rbx), %rax
movq %rax, 0x8(%rsp)
jmp 0x2d2796
movq $0x0, 0x8(%rsp)
cmpl $0x0, (%rbp)
jle 0x2d2871
leaq 0x8(%rbp), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
movl %r13d, 0x4(%rsp)
leaq (%r14,%r14,2), %r15
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x2d2827
movq 0x18(%rsp), %rax
movq (%rax), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
movq %rax, %r12
testl %r13d, %r13d
je 0x2d282a
testq %r12, %r12
je 0x2d282a
testb $0x10, 0x5(%r12)
movq %r12, %r13
je 0x2d27fa
movq %r12, %r13
movq 0x10(%r13), %r13
testb $0x10, 0x5(%r13)
jne 0x2d27ef
movq %r13, %rdi
leaq 0x24(%rsp), %rsi
callq 0x2c95b7
testl %eax, %eax
je 0x2d2820
movb $0x77, (%r13)
andl $0xcffffbff, 0x4(%r13)  # imm = 0xCFFFFBFF
movq $0x0, 0x8(%r13)
movl 0x4(%rsp), %r13d
jmp 0x2d282a
xorl %r12d, %r12d
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2b1a3f
movq %rax, %rbx
testq %rax, %rax
je 0x2d2861
movq 0x10(%rsp), %rax
leaq (%rax,%r15,8), %rax
movb 0x10(%rax), %al
movq 0x8(%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 0x2d27b1
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_O3/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 0x2d2896
movzbl 0x2(%rsi), %eax
cmpl %eax, 0x20(%rdi)
jg 0x2d2896
incb %al
movb %al, 0x2(%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d292f
pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rsi), %r14
testq %r14, %r14
je 0x2d292a
movswq 0x32(%rsi), %r15
movq (%rdi), %rbx
movq (%rbx), %rdi
cmpb $-0x5a, (%rsi)
jne 0x2d28f3
movq 0x20(%r14), %rax
shlq $0x5, %r15
cmpq %rsi, 0x8(%rax,%r15)
jne 0x2d292a
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
testq %rax, %rax
je 0x2d292a
movq 0x20(%r14), %rcx
movq %rax, 0x8(%rcx,%r15)
jmp 0x2d2917
movq 0x30(%r14), %rax
leaq (%r15,%r15,2), %r15
cmpq %rsi, (%rax,%r15,8)
jne 0x2d292a
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
testq %rax, %rax
je 0x2d292a
movq 0x30(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq (%rbx), %rdi
movq 0x58(%rbx), %rsi
movq %rax, %rdx
callq 0x2b1a3f
movq %rax, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d2b14
movq %rsi, 0x20(%rbx)
callq 0x2c0b5b
movq %r14, 0x20(%rbx)
movl $0x1, %eax
jmp 0x2d2b16
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d2e9f
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x2d2d82
cmpl $0x0, (%r12)
jle 0x2d2d82
leaq 0x8(%r12), %r13
xorl %ebx, %ebx
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2d2efa
movq %rax, (%r13)
incq %rbx
movslq (%r12), %rax
addq $0x18, %r13
cmpq %rax, %rbx
jl 0x2d2d62
movq 0x38(%r14), %r12
testq %r12, %r12
je 0x2d2db9
cmpl $0x0, (%r12)
jle 0x2d2db9
leaq 0x8(%r12), %r13
xorl %ebx, %ebx
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2d2efa
movq %rax, (%r13)
incq %rbx
movslq (%r12), %rax
addq $0x18, %r13
cmpq %rax, %rbx
jl 0x2d2d99
movq 0x48(%r14), %r12
testq %r12, %r12
je 0x2d2df0
cmpl $0x0, (%r12)
jle 0x2d2df0
leaq 0x8(%r12), %r13
xorl %ebx, %ebx
movq (%r13), %rsi
movq %r15, %rdi
callq 0x2d2efa
movq %rax, (%r13)
incq %rbx
movslq (%r12), %rax
addq $0x18, %r13
cmpq %rax, %rbx
jl 0x2d2dd0
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x2d2efa
movq %rax, 0x40(%r14)
movq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x2d2efa
movq %rax, 0x30(%r14)
movq %r14, 0x10(%rsp)
movq 0x28(%r14), %r12
movl (%r12), %r13d
testl %r13d, %r13d
jle 0x2d2e86
addq $0x8, %r12
movq 0x28(%r12), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x2d2d2a
testb $0x4, 0x3d(%r12)
je 0x2d2e75
movq 0x60(%r12), %rbp
testq %rbp, %rbp
je 0x2d2e75
cmpl $0x0, (%rbp)
jle 0x2d2e75
leaq 0x8(%rbp), %rbx
xorl %r14d, %r14d
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x2d2efa
movq %rax, (%rbx)
incq %r14
movslq (%rbp), %rax
addq $0x18, %rbx
cmpq %rax, %r14
jl 0x2d2e57
leal -0x1(%r13), %eax
addq $0x70, %r12
cmpl $0x1, %r13d
movl %eax, %r13d
jg 0x2d2e26
cmpl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %r14
je 0x2d2e9f
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x2d2d4b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d2ef9
subq $0x38, %rsp
movq %rdi, %rax
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x20(%rdi)
leaq 0x2e8(%rip), %rdx       # 0x2d31be
movq %rdx, 0x8(%rdi)
leaq -0x9a16(%rip), %rdx     # 0x2c94cb
movq %rdx, 0x10(%rdi)
movq %rsi, 0x28(%rdi)
movq %rcx, 0x58(%rsi)
movq %rax, %rsi
callq 0x2c0b5b
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d31e7
pushq %rbx
movq 0x28(%rdi), %rbx
movl 0x40(%rbx), %eax
cmpl 0x2c(%rsi), %eax
jne 0x2d31e6
movzwl 0x30(%rsi), %edi
testw %di, %di
js 0x2d31e6
movq 0x40(%rsi), %rsi
callq 0x2c6c8f
orq %rax, 0x58(%rbx)
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d3265
movq %rbx, %rdi
movl %ebp, %edx
callq 0x2d3241
testq %rax, %rax
jne 0x2d3287
movq 0x20(%r14), %rax
cmpl %ebp, (%rax)
jle 0x2d3285
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2a9678
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bcb86
movq %rax, %r12
testq %rax, %rax
sete %al
orb %bl, %al
jne 0x2d334a
addq $0x8, %r15
xorl %ebx, %ebx
movq (%r15), %r13
testb $0x1, 0x5(%r13)
jne 0x2d331d
movzwl 0x14(%r15), %edx
decl %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x2d3241
movq %rax, %rbp
testq %rax, %rax
jne 0x2d3309
movq (%rsp), %rax
movq 0x10(%rax), %rbp
movq (%rbp), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2c6cde
movq %rax, (%r15)
jmp 0x2d332b
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a9678
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 0x2d32db
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_O3/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:
testq %rsi, %rsi
je 0x2d38d4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testb $0x1, 0x4(%rbx)
jne 0x2d38c7
movzbl (%rbx), %eax
cmpl $0x2c, %eax
jne 0x2d380a
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2d37c2
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2d37de
jmp 0x2d38c7
cmpl $0x35, %eax
jne 0x2d38c7
movq 0x10(%rbx), %r12
movq 0x18(%rbx), %r15
cmpb $-0x5c, (%r15)
jne 0x2d3874
movw $0x1, 0x24(%rsp)
leaq -0x12ea8(%rip), %rax    # 0x2c0987
movq %rax, 0x8(%rsp)
leaq -0x12dbb(%rip), %rax    # 0x2c0a80
movq %rax, 0x10(%rsp)
movl $0x0, 0x28(%rsp)
testq %r12, %r12
je 0x2d3863
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2c0a8c
cmpw $0x0, 0x24(%r13)
je 0x2d3874
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2d396e
cmpb $-0x5c, (%r12)
jne 0x2d38c7
movq %rsp, %r13
movw $0x1, 0x24(%r13)
leaq -0x12f05(%rip), %rax    # 0x2c0987
movq %rax, 0x8(%r13)
leaq -0x12e17(%rip), %rax    # 0x2c0a80
movq %rax, 0x10(%r13)
movl $0x0, 0x28(%r13)
movq %r13, %rdi
movq %r15, %rsi
callq 0x2c0a8c
cmpw $0x0, 0x24(%r13)
je 0x2d38c7
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2d396e
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d3964
movq %rsi, %r14
movl 0x4(%rsi), %eax
testb $0x9, %al
jne 0x2d3964
movq 0x28(%rdi), %rcx
movslq 0x8(%rcx), %rsi
movl $0x1, %ebx
testq %rsi, %rsi
jle 0x2d3964
movq 0x10(%rcx), %rdx
shlq $0x4, %rsi
xorl %edi, %edi
movq (%rdx,%rdi), %r8
cmpq %r14, %r8
je 0x2d3929
movl 0x2c(%r8), %r9d
cmpl 0x2c(%r14), %r9d
jne 0x2d3929
movzwl 0x30(%r8), %r8d
cmpw 0x30(%r14), %r8w
je 0x2d3934
addq $0x10, %rdi
cmpq %rdi, %rsi
jne 0x2d390a
jmp 0x2d3964
incl 0xc(%rcx)
andl $0xff7ffff6, %eax       # imm = 0xFF7FFFF6
orl $0x8, %eax
movl %eax, 0x4(%r14)
movq 0x8(%rdx,%rdi), %rsi
testq %rsi, %rsi
je 0x2d395e
movq (%rcx), %rax
movq (%rax), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
jmp 0x2d3960
xorl %eax, %eax
movq %rax, 0x10(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d399f
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 0x2c08a4
testb %al, %al
je 0x2d39a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rdi
movl $0x200, %eax            # imm = 0x200
xorl %ecx, %ecx
andl 0x4(%r12), %eax
sete %cl
shrl $0x6, %eax
movq 0x10(%r12,%rax), %rsi
movq 0x10(%r12,%rcx,8), %rdx
callq 0x2a9634
testq %rax, %rax
je 0x2d39d6
leaq 0x90(%rip), %rcx        # 0x2d3a60
cmpq %rcx, 0x18(%rax)
jne 0x2d3994
movslq 0x8(%r14), %rax
movq 0x10(%r14), %rsi
testq %rax, %rax
jle 0x2d3a0f
movl 0x2c(%r15), %ecx
movq %rax, %rdx
shlq $0x4, %rdx
xorl %edi, %edi
movq (%rsi,%rdi), %r8
cmpl %ecx, 0x2c(%r8)
jne 0x2d3a06
movzwl 0x30(%r8), %r8d
cmpw 0x30(%r15), %r8w
je 0x2d3994
addq $0x10, %rdi
cmpq %rdi, %rdx
jne 0x2d39f0
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
movq (%r14), %rcx
movq (%rcx), %rdi
leal 0x2(,%rax,2), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x2919d2
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x2d3a53
movslq 0x8(%r14), %rcx
shlq $0x4, %rcx
movq %r15, -0x10(%rax,%rcx)
movq 0x10(%r14), %rax
movq %rbx, -0x8(%rax,%rcx)
jmp 0x2d3994
movl $0x0, 0x8(%r14)
jmp 0x2d3994
// File: /workspace/github_c_makefile_star2_O3/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 0x2d3af6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x2d3a9e
movl 0x28(%rax), %eax
cmpl (%rbx), %eax
jle 0x2d3a9e
movl %eax, (%rbx)
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x2d3ab0
movl 0x28(%rax), %eax
cmpl (%rbx), %eax
jle 0x2d3ab0
movl %eax, (%rbx)
movq 0x60(%r14), %rax
testq %rax, %rax
je 0x2d3ac2
movl 0x28(%rax), %eax
cmpl (%rbx), %eax
jle 0x2d3ac2
movl %eax, (%rbx)
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x2d3af7
movq 0x38(%r14), %rdi
movq %rbx, %rsi
callq 0x2d3af7
movq 0x48(%r14), %rdi
movq %rbx, %rsi
callq 0x2d3af7
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x2d3a8c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x2d3b8e
movzbl %bl, %ebp
movq %rsi, %r15
movl 0x4(%r15), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2d3b6e
btl $0x12, %eax
jb 0x2d3b5c
addq $0x10, %r15
jmp 0x2d3b64
movq 0x20(%r15), %r15
addq $0x8, %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x2d3b45
jmp 0x2d3b8e
movb %bl, 0x10(%r14)
cmpb %bl, (%r15)
jne 0x2d3b9d
movq 0x10(%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x2d3b2e
movq 0x18(%r15), %rsi
testq %rsi, %rsi
jne 0x2d3b42
movb %bl, 0x10(%r14)
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 0x2d76c5
// File: /workspace/github_c_makefile_star2_O3/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 0x2d4441
movq %rsi, %rbx
movl (%rsi), %ecx
testl %ecx, %ecx
jle 0x2d4441
movq %rdi, %r14
leaq 0x8(%rbx), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
movq (%r12), %rsi
testq %rsi, %rsi
je 0x2d442b
movq %r14, %rdi
callq 0x2d95bc
movl (%rbx), %ecx
jmp 0x2d442d
xorl %eax, %eax
orq %rax, %r15
incq %r13
movslq %ecx, %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x2d4416
jmp 0x2d4444
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movb 0x40(%rsi), %al
testb %al, %al
je 0x2d767d
leaq 0x3e8(%rbx), %r15
xorl %r12d, %r12d
movq (%r15), %rcx
testq %rcx, %rcx
je 0x2d766e
testb $0x8, 0x29(%rcx)
je 0x2d766e
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x2d766e
movq %r14, %rdi
callq 0x282904
movb 0x40(%rbx), %al
incq %r12
movzbl %al, %ecx
addq $0x60, %r15
cmpq %rcx, %r12
jb 0x2d764c
leaq 0x68(%rbx), %rdi
callq 0x2de2b3
movq 0x50(%rbx), %r15
testq %r15, %r15
je 0x2d76af
movq 0x40(%r15), %rax
movq %rax, 0x50(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2db02e
movq %r14, %rdi
movq %r15, %rsi
callq 0x282904
jmp 0x2d7686
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x282904
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprMightBeIndexed
static int exprMightBeIndexed(
  SrcList *pFrom,        /* The FROM clause */
  Bitmask mPrereq,       /* Bitmask of FROM clause terms referenced by pExpr */
  int *aiCurCol,         /* Write the referenced table cursor & column here */
  Expr *pExpr,           /* An operand of a comparison operator */
  int op                 /* The specific comparison operator */
){
  /* If this expression is a vector to the left or right of a
  ** inequality constraint (>, <, >= or <=), perform the processing
  ** on the first element of the vector.  */
  assert( TK_GT+1==TK_LE && TK_GT+2==TK_LT && TK_GT+3==TK_GE );
  assert( TK_IS<TK_GE && TK_ISNULL<TK_GE && TK_IN<TK_GE );
  assert( op<=TK_GE );
  if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){
    pExpr = pExpr->x.pList->a[0].pExpr;
  }

  if( pExpr->op==TK_COLUMN ){
    aiCurCol[0] = pExpr->iTable;
    aiCurCol[1] = pExpr->iColumn;
    return 1;
  }
  if( mPrereq==0 ) return 0;                 /* No table references */
  if( (mPrereq&(mPrereq-1))!=0 ) return 0;   /* Refs more than one table */
  return exprMightBeIndexed2(pFrom,mPrereq,aiCurCol,pExpr);
}

// Assembly:
movb (%rcx), %al
cmpb $-0x52, %al
setne %r9b
addl $-0x36, %r8d
cmpl $0x4, %r8d
setae %r8b
orb %r9b, %r8b
jne 0x2d9854
movq 0x20(%rcx), %rax
movq 0x8(%rax), %rcx
movb (%rcx), %al
cmpb $-0x5c, %al
jne 0x2d986a
movl 0x2c(%rcx), %eax
movl %eax, (%rdx)
movswl 0x30(%rcx), %eax
movl %eax, 0x4(%rdx)
movl $0x1, %eax
retq
leaq -0x1(%rsi), %r8
movq %rsi, %r9
xorq %r8, %r9
xorl %eax, %eax
cmpq %r8, %r9
ja 0x2d9a3b
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d9992
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x35, %eax
je 0x2d98ad
cmpl $0x2d, %eax
jne 0x2d9992
testb $0x1, 0x4(%r14)
jne 0x2d9992
movq 0x10(%r14), %rdi
callq 0x2c08a4
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x2c08a4
cmpb %al, %r15b
je 0x2d98e6
cmpb $0x43, %r15b
setl %cl
cmpb $0x43, %al
setl %al
orb %cl, %al
jne 0x2d9992
movl $0x200, %eax            # imm = 0x200
xorl %ecx, %ecx
andl 0x4(%r14), %eax
sete %cl
shrl $0x6, %eax
movq 0x10(%r14,%rax), %rsi
movq 0x10(%r14,%rcx,8), %rdx
movq %rbx, %rdi
callq 0x2a9634
movl $0x1, %ebp
testq %rax, %rax
je 0x2d9992
leaq -0x5eba(%rip), %rcx     # 0x2d3a60
cmpq %rcx, 0x18(%rax)
je 0x2d9992
movq 0x10(%r14), %rsi
movq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0x2a9678
movq %rax, %r14
testq %rax, %rax
jne 0x2d993f
movq (%rbx), %rax
movq 0x10(%rax), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a9678
testq %rax, %rax
jne 0x2d9956
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq (%r14), %rcx
movq (%rax), %rax
xorl %edx, %edx
leaq 0xf797b(%rip), %rsi     # 0x3d12e0
movzbl (%rcx,%rdx), %edi
movzbl (%rax,%rdx), %r8d
cmpb %r8b, %dil
jne 0x2d997a
testq %rdi, %rdi
jne 0x2d9984
jmp 0x2d9989
movb (%rdi,%rsi), %r9b
cmpb (%r8,%rsi), %r9b
jne 0x2d9989
incq %rdx
jmp 0x2d9965
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_O3/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 0x2d99e5
cmpl $0x88, %eax
jne 0x2d99fa
xorl %r14d, %r14d
movq %r15, %rdi
movl $0xaf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2ad3b5
testq %rax, %rax
je 0x2d9a26
movw %bp, 0x30(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %r14
jmp 0x2d9a26
movq 0x20(%rbx), %rax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rbx
testq %rbx, %rbx
je 0x2d9a34
movq (%r15), %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
movq %rax, %r14
movq 0x1a0(%r15), %rax
testq %rax, %rax
je 0x2d9a26
cmpq %rbx, (%rax)
je 0x2d9a23
movq 0x18(%rax), %rax
jmp 0x2d9a13
movq %r14, (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x2d9a0c
// File: /workspace/github_c_makefile_star2_O3/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 0x2d9a68
movq %rsi, %rdx
shrq %rdx
incq %rcx
cmpq $0x3, %rsi
movq %rdx, %rsi
ja 0x2d9a59
imulq $0x70, %rcx, %rcx
movq 0x28(%rdi,%rcx), %rdx
movq 0x10(%rdx), %r15
testq %r15, %r15
je 0x2d9ae9
movl 0x48(%rdi,%rcx), %ebp
cmpq $0x0, 0x50(%r15)
je 0x2d9ace
movzwl 0x5e(%r15), %eax
testw %ax, %ax
je 0x2d9ace
movl $0x4, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rcx
cmpw $-0x2, (%rcx,%r13,2)
jne 0x2d9abf
movq 0x50(%r15), %rax
movq (%rax,%r12,2), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x2d9af8
testl %eax, %eax
je 0x2d9adb
movzwl 0x5e(%r15), %eax
incq %r13
movzwl %ax, %ecx
addq $0xc, %r12
cmpq %rcx, %r13
jb 0x2d9a98
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x2d9a7e
xorl %eax, %eax
jmp 0x2d9ae9
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_O3/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
testq %rdi, %rdi
je 0x2d9b2b
movq %rdi, %rsi
movl 0x4(%rsi), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2d9b2d
btl $0x12, %eax
jb 0x2d9b1b
addq $0x10, %rsi
jmp 0x2d9b23
movq 0x20(%rsi), %rsi
addq $0x8, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x2d9b05
xorl %esi, %esi
testq %rdx, %rdx
je 0x2d9b55
movl 0x4(%rdx), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2d9b57
btl $0x12, %eax
jb 0x2d9b48
addq $0x10, %rdx
jmp 0x2d9b50
movq 0x20(%rdx), %rdx
addq $0x8, %rdx
movq (%rdx), %rdx
jmp 0x2d9b2d
xorl %edx, %edx
xorl %edi, %edi
jmp 0x2c0d98
// File: /workspace/github_c_makefile_star2_O3/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 0x2d9bef
testq %rax, %rax
je 0x2d9bd8
andl $0x82, %ebx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq 0x30(%rax), %rcx
testq %r14, %rcx
jne 0x2d9bc9
testq %rcx, %rcx
jne 0x2d9bc2
movzwl 0x14(%rax), %ecx
testl %ecx, %ebx
jne 0x2d9bea
testq %r15, %r15
cmoveq %rax, %r15
movq %r12, %rdi
callq 0x2d9c93
testq %rax, %rax
jne 0x2d9bac
jmp 0x2d9bdb
xorl %r15d, %r15d
movq %r15, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x2d9bdb
// File: /workspace/github_c_makefile_star2_O3/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:
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 0x2d9c52
movq 0x8(%r9), %rdx
movslq %ecx, %rax
movswl (%rdx,%rax,2), %edx
cmpl $-0x2, %edx
jne 0x2d9c5a
movq 0x50(%r9), %rcx
leaq (%rax,%rax,2), %rdx
movq 0x8(%rcx,%rdx,8), %rcx
movq %rcx, 0x18(%rdi)
movq 0x40(%r9), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
movw $0xfffe, 0x58(%rdi)     # imm = 0xFFFE
jmp 0x2d9eef
cmpl $-0x2, %ecx
jne 0x2d9c8d
xorl %eax, %eax
retq
movq 0x18(%r9), %rsi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpw 0x44(%rsi), %dx
je 0x2d9c8d
testw %dx, %dx
js 0x2d9c8b
movq 0x8(%rsi), %rcx
movl %edx, %esi
shlq $0x5, %rsi
movb 0x19(%rcx,%rsi), %cl
movb %cl, 0x20(%rdi)
movq 0x40(%r9), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rdi)
movl %edx, %ecx
movw %cx, 0x58(%rdi)
jmp 0x2d9c93
// File: /workspace/github_c_makefile_star2_O3/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 0x2c08a4
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x2d9f3e
testb $0x8, 0x5(%r14)
jne 0x2d9f32
testb %al, %al
jne 0x2d9f46
movb $0x1, %cl
jmp 0x2d9f5c
movq 0x20(%r14), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %rdi
movsbl %al, %esi
callq 0x2c0948
movb $0x1, %cl
cmpb $0x42, %al
jl 0x2d9f5c
jne 0x2d9f56
cmpb $0x42, %bl
sete %cl
jmp 0x2d9f5c
cmpb $0x43, %bl
setge %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2db0e8
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
addl $0x7, %r14d
andl $-0x8, %r14d
leaq (,%r14,8), %rsi
callq 0x282a35
testq %rax, %rax
je 0x2db0e3
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 0x2db0d8
movq %r12, %rdi
callq 0x282904
movq %r13, 0x38(%r15)
movw %r14w, 0x30(%r15)
jmp 0x2db0e8
movl $0x7, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2db980
movzwl 0x2c(%rdi), %ecx
movl %ecx, %r9d
subl %edx, %r9d
movzwl 0x2c(%rsi), %edx
movl %edx, %r10d
subl %r8d, %r10d
cmpl %r10d, %r9d
jge 0x2db980
movzwl 0x14(%rsi), %r8d
cmpw %r8w, 0x14(%rdi)
jge 0x2db972
pushq %rbx
testq %rcx, %rcx
je 0x2db95f
movq 0x38(%rdi), %r8
movq -0x8(%r8,%rcx,8), %r9
testq %r9, %r9
je 0x2db952
movq %rdx, %r10
testq %r10, %r10
jle 0x2db970
leaq -0x1(%r10), %r11
movq 0x38(%rsi), %rbx
cmpq %r9, -0x8(%rbx,%r10,8)
movq %r11, %r10
jne 0x2db93b
leaq -0x1(%rcx), %r9
cmpq $0x1, %rcx
movq %r9, %rcx
jg 0x2db92e
testb $0x40, 0x28(%rdi)
je 0x2db96b
testb $0x40, 0x28(%rsi)
je 0x2db970
movl $0x1, %eax
popq %rbx
retq
jg 0x2db980
movzwl 0x16(%rdi), %r8d
cmpw 0x16(%rsi), %r8w
jle 0x2db924
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2dba45
movzwl 0x14(%rdi), %eax
testb $-0x7e, %al
je 0x2dba45
testb $0x8, 0x3c(%rsi)
jne 0x2dba36
testq %rdx, 0x30(%rdi)
jne 0x2dba45
movslq 0x28(%rdi), %rax
testq %rax, %rax
js 0x2dba45
movq 0x20(%rsi), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movsbl 0x19(%rcx,%rax), %esi
movq (%rdi), %rdi
jmp 0x2d9f08
testb %al, %al
jns 0x2dba0e
movq (%rdi), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
jne 0x2dba0e
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereUsablePartialIndex
static int whereUsablePartialIndex(
  int iTab,             /* The table for which we want an index */
  int isLeft,           /* True if iTab is the right table of a LEFT JOIN */
  WhereClause *pWC,     /* The WHERE clause of the query */
  Expr *pWhere          /* The WHERE clause from the partial index */
){
  int i;
  WhereTerm *pTerm;
  Parse *pParse = pWC->pWInfo->pParse;
  while( pWhere->op==TK_AND ){
    if( !whereUsablePartialIndex(iTab,isLeft,pWC,pWhere->pLeft) ) return 0;
    pWhere = pWhere->pRight;
  }
  if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0;
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr;
    pExpr = pTerm->pExpr;
    if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
     && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
     && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
movq (%rdx), %rax
movq (%rax), %r12
cmpb $0x2c, (%rcx)
jne 0x2dba87
movq 0x10(%rbx), %rcx
movl %r15d, %edi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2dba48
testl %eax, %eax
je 0x2dbae4
movq 0x18(%rbx), %rbx
cmpb $0x2c, (%rbx)
je 0x2dba69
movq (%r12), %rcx
xorl %eax, %eax
testb $-0x80, 0x32(%rcx)
cmovneq %rax, %r12
movq %r12, (%rsp)
movl 0x14(%r14), %ecx
testl %ecx, %ecx
jle 0x2dbae6
movq 0x20(%r14), %r13
xorl %r12d, %r12d
movq (%r13), %rsi
testb $0x1, 0x4(%rsi)
jne 0x2dbab8
testl %ebp, %ebp
jne 0x2dbad8
jmp 0x2dbac1
movswl 0x34(%rsi), %eax
cmpl %r15d, %eax
jne 0x2dbad8
movq (%rsp), %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x2c1375
testl %eax, %eax
jne 0x2dbaf5
movl 0x14(%r14), %ecx
incl %r12d
addq $0x40, %r13
cmpl %ecx, %r12d
jl 0x2dbaa8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x2dbae6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCoveredByIndex
SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(
  Expr *pExpr,        /* The index to be tested */
  int iCur,           /* The cursor number for the corresponding table */
  Index *pIdx         /* The index that might be used for coverage */
){
  Walker w;
  struct IdxCover xcov;
  memset(&w, 0, sizeof(w));
  xcov.iCur = iCur;
  xcov.pIdx = pIdx;
  w.xExprCallback = exprIdxCover;
  w.u.pIdxCover = &xcov;
  sqlite3WalkExpr(&w, pExpr);
  return !w.eCode;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x30(%rsp), %rcx
movl %esi, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x914(%rip), %rdx       # 0x2dc573
movq %rdx, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
testq %rdi, %rdi
je 0x2dbc8b
movq %rdi, %rax
movq %rsp, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2c0a8c
xorl %eax, %eax
cmpw $0x0, 0x24(%rbx)
sete %al
jmp 0x2dbc90
movl $0x1, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprIdxCover
static int exprIdxCover(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_COLUMN
   && pExpr->iTable==pWalker->u.pIdxCover->iCur
   && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
  ){
    pWalker->eCode = 1;
    return WRC_Abort;
  }
  return WRC_Continue;
}

// Assembly:
xorl %eax, %eax
cmpb $-0x5c, (%rsi)
jne 0x2dc5be
movl 0x2c(%rsi), %edx
movq 0x28(%rdi), %rcx
cmpl 0x8(%rcx), %edx
jne 0x2dc5be
movq (%rcx), %rcx
movzwl 0x60(%rcx), %eax
testq %rax, %rax
je 0x2dc5b3
movzwl 0x30(%rsi), %edx
movq 0x8(%rcx), %rsi
xorl %ecx, %ecx
cmpw %dx, (%rsi,%rcx,2)
je 0x2dc5ac
incq %rcx
cmpq %rcx, %rax
jne 0x2dc59c
jmp 0x2dc5b3
xorl %eax, %eax
testw %cx, %cx
jns 0x2dc5be
movw $0x1, 0x24(%rdi)
movl $0x2, %eax
retq