LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rdi), %r15d
movslq 0x18(%rdi), %rsi
cmpl %esi, %r15d
jl 0x277328
movq (%rbx), %rax
movq 0x20(%rbx), %r15
movq (%rax), %rax
movq (%rax), %r12
shlq $0x7, %rsi
movq %r12, %rdi
callq 0x22d205
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x277396
movslq 0x14(%rbx), %rdx
shlq $0x6, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x17630
leaq 0x28(%rbx), %rax
cmpq %rax, %r15
je 0x277312
movq %r12, %rdi
movq %r15, %rsi
callq 0x21f26b
movq 0x20(%rbx), %rsi
movq %r12, %rdi
callq 0x22103d
sarl $0x6, %eax
movl %eax, 0x18(%rbx)
movl 0x14(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x14(%rbx)
movslq %r15d, %r12
shlq $0x6, %r12
addq 0x20(%rbx), %r12
movw $0x1, %ax
testq %r14, %r14
je 0x277358
testb $0x4, 0x6(%r14)
je 0x277358
movslq 0x2c(%r14), %rdi
callq 0x243f7b
addl $0xfffffef2, %eax       # imm = 0xFFFFFEF2
movw %ax, 0x10(%r12)
movq %r14, %rdi
callq 0x267d34
movq %rax, (%r12)
movw %bp, 0x12(%r12)
movq %rbx, 0x8(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%r12)
movups %xmm0, 0x24(%r12)
movups %xmm0, 0x30(%r12)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, %bpl
je 0x2773a7
movq %r12, %rdi
movq %r14, %rsi
callq 0x24b639
movq %r15, 0x20(%rbx)
xorl %r15d, %r15d
jmp 0x27738a
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprSelectUsage
static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){
  Bitmask mask = 0;
  while( pS ){
    SrcList *pSrc = pS->pSrc;
    mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pEList);
    mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pGroupBy);
    mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pOrderBy);
    mask |= sqlite3WhereExprUsage(pMaskSet, pS->pWhere);
    mask |= sqlite3WhereExprUsage(pMaskSet, pS->pHaving);
    if( ALWAYS(pSrc!=0) ){
      int i;
      for(i=0; i<pSrc->nSrc; i++){
        mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect);
        mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].pOn);
        if( pSrc->a[i].fg.isTabFunc ){
          mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg);
        }
      }
    }
    pS = pS->pPrior;
  }
  return mask;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r12
xorl %eax, %eax
movq %rdi, 0x10(%rsp)
testq %rbx, %rbx
je 0x278bb7
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %r14
movq %r12, %rdi
movq %rax, (%rsp)
callq 0x276e4a
movq %rax, 0x8(%rsp)
movq 0x38(%rbx), %rsi
movq %r12, %rdi
callq 0x276e4a
movq %rax, %rbp
movq 0x48(%rbx), %rsi
movq %r12, %rdi
callq 0x276e4a
movq %rax, %r15
movq 0x30(%rbx), %rsi
movq %r12, %rdi
callq 0x278aa4
movq %rax, %r13
movq 0x40(%rbx), %rsi
movq %r12, %rdi
callq 0x278aa4
orq 0x8(%rsp), %rbp
orq %r15, %r13
orq %rbp, %r13
orq (%rsp), %rax
orq %r13, %rax
testq %r14, %r14
je 0x278ba9
movq %rax, (%rsp)
movq %rbx, 0x8(%rsp)
leaq 0x30(%r14), %rbp
xorl %ebx, %ebx
movslq (%r14), %rax
cmpq %rax, %rbx
jge 0x278ba0
movq (%rbp), %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x278ab0
movq %rax, %r13
movq 0x20(%rbp), %rsi
movq %r12, %rdi
callq 0x278aa4
movq %rax, %r15
orq %r13, %r15
orq (%rsp), %r15
testb $0x4, 0x15(%rbp)
je 0x278b93
movq 0x38(%rbp), %rsi
movq %r12, %rdi
callq 0x276e4a
orq %rax, %r15
incq %rbx
addq $0x70, %rbp
movq %r15, (%rsp)
jmp 0x278b4c
movq 0x8(%rsp), %rbx
movq (%rsp), %rax
movq 0x50(%rbx), %rbx
movq 0x10(%rsp), %r12
jmp 0x278acb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WhereExprUsageNN
SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){
  Bitmask mask;
  if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){
    return sqlite3WhereGetMask(pMaskSet, p->iTable);
  }else if( ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){
    assert( p->op!=TK_IF_NULL_ROW );
    return 0;
  }
  mask = (p->op==TK_IF_NULL_ROW) ? sqlite3WhereGetMask(pMaskSet, p->iTable) : 0;
  if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft);
  if( p->pRight ){
    mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight);
    assert( p->x.pList==0 );
  }else if( ExprHasProperty(p, EP_xIsSelect) ){
    if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1;
    mask |= exprSelectUsage(pMaskSet, p->x.pSelect);
  }else if( p->x.pList ){
    mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList);
  }
#ifndef SQLITE_OMIT_WINDOWFUNC
  if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && p->y.pWin ){
    mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition);
    mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy);
    mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter);
  }
#endif
  return mask;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %cl
movl 0x4(%rsi), %eax
cmpb $-0x5c, %cl
jne 0x278bf8
testb $0x8, %al
jne 0x278c07
movl 0x2c(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x278cf3
testl $0x804000, %eax         # imm = 0x804000
je 0x278c17
xorl %r15d, %r15d
jmp 0x278ce6
xorl %r15d, %r15d
testl $0x804000, %eax         # imm = 0x804000
jne 0x278ce6
jmp 0x278c30
cmpb $-0x50, %cl
jne 0x278c2d
movl 0x2c(%r14), %esi
movq %rbx, %rdi
callq 0x278cf3
movq %rax, %r15
jmp 0x278c30
xorl %r15d, %r15d
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x278c44
movq %rbx, %rdi
callq 0x278bc6
orq %rax, %r15
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x278c57
movq %rbx, %rdi
callq 0x278bc6
jmp 0x278c8a
movl 0x4(%r14), %eax
btl $0xb, %eax
jb 0x278c74
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x278c8d
movq %rbx, %rdi
callq 0x276e4a
jmp 0x278c8a
testb $0x20, %al
je 0x278c7e
movl $0x1, (%rbx)
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x278ab0
orq %rax, %r15
movzbl (%r14), %eax
cmpl $0xa9, %eax
je 0x278c9f
cmpl $0xa5, %eax
jne 0x278ce6
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x278ce6
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x276e4a
movq %rax, %r12
movq 0x40(%r14), %rax
movq 0x18(%rax), %rsi
movq %rbx, %rdi
callq 0x276e4a
movq %rax, %r13
movq 0x40(%r14), %rax
movq 0x48(%rax), %rsi
movq %rbx, %rdi
callq 0x278aa4
orq %r12, %r13
orq %r15, %rax
orq %r13, %rax
movq %rax, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x278d46
movq 0x20(%rcx), %rax
movq 0x8(%rax), %rcx
movb (%rcx), %al
cmpb $-0x5c, %al
jne 0x278d5a
movl 0x2c(%rcx), %eax
movl %eax, (%rdx)
movswl 0x30(%rcx), %eax
movl %eax, 0x4(%rdx)
pushq $0x1
popq %rax
retq
leaq -0x1(%rsi), %r8
movq %rsi, %r9
xorq %r8, %r9
xorl %eax, %eax
cmpq %r8, %r9
ja 0x278e58
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movzbl (%rsi), %eax
cmpl $0xae, %eax
je 0x278e1c
cmpl $0x88, %eax
jne 0x278e2c
xorl %r15d, %r15d
movq %r14, %rdi
movl $0xaf, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x254915
testq %rax, %rax
je 0x278e4a
movw %bp, 0x30(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %r15
jmp 0x278e4a
movq 0x20(%rbx), %rax
movslq %ebp, %rcx
imulq $0x18, %rcx, %rcx
movq 0x8(%rax,%rcx), %rbx
movq (%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x267197
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x26ae3e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, (%rsp)
addq $0x48, %rdi
cmpq $0x2, %rsi
jb 0x278e7d
shrq %rsi
addq $0x70, %rdi
jmp 0x278e6e
movl (%rdi), %ebp
movq -0x20(%rdi), %r12
addq $0x10, %r12
xorl %r15d, %r15d
movq (%r12), %r12
testq %r12, %r12
je 0x278eef
cmpq $0x0, 0x50(%r12)
je 0x278ed8
pushq $0x4
popq %r13
xorl %ebx, %ebx
movzwl 0x5e(%r12), %eax
cmpq %rax, %rbx
jae 0x278ed8
movq 0x8(%r12), %rax
cmpw $-0x2, (%rax,%rbx,2)
jne 0x278ecf
movq 0x50(%r12), %rax
movq (%rax,%r13,2), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x278f01
testl %eax, %eax
je 0x278ede
incq %rbx
addq $0xc, %r13
jmp 0x278ea1
addq $0x28, %r12
jmp 0x278e8a
movq (%rsp), %rax
movl %ebp, (%rax)
movl $0xfffffffe, 0x4(%rax)  # imm = 0xFFFFFFFE
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
callq 0x267d34
movq %rax, %r15
movq %r14, %rdi
callq 0x267d34
xorl %edi, %edi
movq %r15, %rsi
movq %rax, %rdx
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x26823c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereNthSubterm
static WhereTerm *whereNthSubterm(WhereTerm *pTerm, int N){
  if( pTerm->eOperator!=WO_AND ){
    return N==0 ? pTerm : 0;
  }
  if( N<pTerm->u.pAndInfo->wc.nTerm ){
    return &pTerm->u.pAndInfo->wc.a[N];
  }
  return 0;
}

// Assembly:
cmpw $0x400, 0x14(%rdi)      # imm = 0x400
jne 0x278f4c
movq 0x28(%rdi), %rcx
cmpl %esi, 0x14(%rcx)
jle 0x278f55
movslq %esi, %rax
shlq $0x6, %rax
addq 0x20(%rcx), %rax
retq
xorl %eax, %eax
testl %esi, %esi
cmoveq %rdi, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r15
movq %r15, %rdi
callq 0x279007
andl $0x82, %ebx
xorl %r12d, %r12d
testq %rax, %rax
je 0x278fcb
movq 0x30(%rax), %rcx
testq %r14, %rcx
jne 0x278fbe
testq %rcx, %rcx
jne 0x278fb7
movzwl 0x14(%rax), %ecx
testl %ecx, %ebx
jne 0x278fc8
testq %r12, %r12
cmoveq %rax, %r12
movq %r15, %rdi
callq 0x2790a6
jmp 0x278f9c
movq %rax, %r12
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: indexColumnNotNull
static int indexColumnNotNull(Index *pIdx, int iCol){
  int j;
  assert( pIdx!=0 );
  assert( iCol>=0 && iCol<pIdx->nColumn );
  j = pIdx->aiColumn[iCol];
  if( j>=0 ){
    return pIdx->pTable->aCol[j].notNull;
  }else if( j==(-1) ){
    return 1;
  }else{
    assert( j==(-2) );
    return 0;  /* Assume an indexed expression can always yield a NULL */

  }
}

// Assembly:
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movswq (%rax,%rcx,2), %rcx
testq %rcx, %rcx
js 0x278ffd
movq 0x18(%rdi), %rax
movq 0x8(%rax), %rax
shlq $0x5, %rcx
movzbl 0x18(%rax,%rcx), %eax
retq
xorl %eax, %eax
cmpw $-0x1, %cx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andl $0x0, 0x28(%rdi)
movl %edx, 0x2c(%rdi)
movw $0x101, 0x21(%rdi)      # imm = 0x101
testq %r9, %r9
je 0x279067
movq 0x8(%r9), %rdx
movslq %ecx, %rax
movswl (%rdx,%rax,2), %ecx
cmpl $-0x2, %ecx
jne 0x27906f
movq 0x50(%r9), %rcx
imulq $0x18, %rax, %rdx
movq 0x8(%rcx,%rdx), %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 0x279291
cmpl $-0x2, %ecx
jne 0x2790a0
xorl %eax, %eax
retq
movq 0x18(%r9), %rdx
cmpw 0x44(%rdx), %cx
jne 0x27907e
pushq $-0x1
popq %rcx
jmp 0x2790a0
testw %cx, %cx
js 0x2790a0
movq 0x8(%rdx), %rdx
movl %ecx, %esi
shlq $0x5, %rsi
movb 0x19(%rdx,%rsi), %dl
movb %dl, 0x20(%rdi)
movq 0x40(%r9), %rdx
movq (%rdx,%rax,8), %rax
movq %rax, 0x10(%rdi)
movw %cx, 0x58(%rdi)
jmp 0x2790a6
// File: /workspace/github_c_makefile_star2_O2/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 0x267d81
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x2792e0
testb $0x8, 0x5(%r14)
jne 0x2792d4
testb %al, %al
jne 0x2792e8
movb $0x1, %cl
jmp 0x2792fe
movq 0x20(%r14), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %rdi
movsbl %al, %esi
callq 0x267e25
movb $0x1, %cl
cmpb $0x42, %al
jl 0x2792fe
jne 0x2792f8
cmpb $0x42, %bl
sete %cl
jmp 0x2792fe
cmpb $0x43, %bl
setge %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27a3dd
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
addl $0x7, %r14d
andl $-0x8, %r14d
leaq (,%r14,8), %rsi
callq 0x22d205
testq %rax, %rax
je 0x27a3da
movq %rax, %r13
movq 0x38(%r15), %rsi
movzwl 0x30(%r15), %edx
shll $0x3, %edx
movq %rax, %rdi
callq 0x17630
movq 0x38(%r15), %rsi
leaq 0x48(%r15), %rax
cmpq %rax, %rsi
je 0x27a3cf
movq %r12, %rdi
callq 0x22d0fc
movq %r13, 0x38(%r15)
movw %r14w, 0x30(%r15)
jmp 0x27a3dd
pushq $0x7
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27abbb
movzwl 0x2c(%rdi), %ecx
movl %ecx, %r9d
subl %edx, %r9d
movzwl 0x2c(%rsi), %edx
movl %edx, %r10d
subl %r8d, %r10d
cmpl %r10d, %r9d
jge 0x27abbb
movzwl 0x14(%rsi), %r8d
cmpw %r8w, 0x14(%rdi)
jge 0x27abad
testq %rcx, %rcx
jle 0x27abbc
movq 0x38(%rdi), %r8
movq -0x8(%r8,%rcx,8), %r8
decq %rcx
testq %r8, %r8
je 0x27ab7b
movq %rdx, %r9
testq %r9, %r9
jle 0x27abbb
leaq -0x1(%r9), %r10
movq 0x38(%rsi), %r11
cmpq %r8, -0x8(%r11,%r9,8)
movq %r10, %r9
jne 0x27ab94
jmp 0x27ab7b
jg 0x27abbb
movzwl 0x16(%rdi), %r8d
cmpw 0x16(%rsi), %r8w
jle 0x27ab7b
retq
testb $0x40, 0x28(%rdi)
je 0x27abc8
testb $0x40, 0x28(%rsi)
je 0x27abbb
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27ac9e
movzwl 0x14(%rdi), %eax
testb $-0x7e, %al
je 0x27ac9e
testb $0x8, 0x3c(%rsi)
jne 0x27ac8f
testq %rdx, 0x30(%rdi)
jne 0x27ac9e
movslq 0x28(%rdi), %rax
testq %rax, %rax
js 0x27ac9e
movq 0x20(%rsi), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movsbl 0x19(%rcx,%rax), %esi
movq (%rdi), %rdi
jmp 0x2792aa
testb %al, %al
jns 0x27ac67
movq (%rdi), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
jne 0x27ac67
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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, (%rbx)
jne 0x27acdd
movq 0x10(%rbx), %rcx
movl %r15d, %edi
movl %ebp, %esi
movq %r14, %rdx
callq 0x27aca1
testl %eax, %eax
je 0x27ad31
movq 0x18(%rbx), %rbx
jmp 0x27acbd
movq (%r12), %rax
xorl %ecx, %ecx
testb $-0x80, 0x32(%rax)
cmovneq %rcx, %r12
movq %r12, (%rsp)
movq 0x20(%r14), %r13
xorl %r12d, %r12d
cmpl 0x14(%r14), %r12d
jge 0x27ad31
movq (%r13), %rsi
testb $0x1, 0x4(%rsi)
jne 0x27ad0c
testl %ebp, %ebp
jne 0x27ad28
jmp 0x27ad15
movswl 0x34(%rsi), %eax
cmpl %r15d, %eax
jne 0x27ad28
movq (%rsp), %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x26877f
testl %eax, %eax
jne 0x27ad42
incl %r12d
addq $0x40, %r13
jmp 0x27acf6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rax
jmp 0x27ad33
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
andq $0x0, 0x20(%rbx)
movaps %xmm0, (%rbx)
movaps %xmm0, 0x10(%rbx)
movq %rsp, %rcx
movl %esi, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x7bd(%rip), %rdx       # 0x27b656
movq %rdx, 0x8(%rbx)
movq %rcx, 0x28(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x267f87
xorl %eax, %eax
cmpw $0x0, 0x24(%rbx)
sete %al
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $-0x5c, (%rsi)
jne 0x27b68b
movq %rdi, %r14
movl 0x2c(%rsi), %ecx
movq 0x28(%rdi), %rax
cmpl 0x8(%rax), %ecx
jne 0x27b68b
movq (%rax), %rdi
movswl 0x30(%rsi), %esi
callq 0x267859
testw %ax, %ax
jns 0x27b68b
movw $0x1, 0x24(%r14)
pushq $0x2
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: translateColumnToCopy
static void translateColumnToCopy(
  Parse *pParse,      /* Parsing context */
  int iStart,         /* Translate from this opcode to the end */
  int iTabCur,        /* OP_Column/OP_Rowid references to this table */
  int iRegister,      /* The first column is in this register */
  int iAutoidxCur     /* If non-zero, cursor of autoindex being generated */
){
  Vdbe *v = pParse->pVdbe;
  VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
  int iEnd = sqlite3VdbeCurrentAddr(v);
  if( pParse->db->mallocFailed ) return;
  for(; iStart<iEnd; iStart++, pOp++){
    if( pOp->p1!=iTabCur ) continue;
    if( pOp->opcode==OP_Column ){
      pOp->opcode = OP_Copy;
      pOp->p1 = pOp->p2 + iRegister;
      pOp->p2 = pOp->p3;
      pOp->p3 = 0;
    }else if( pOp->opcode==OP_Rowid ){
      if( iAutoidxCur ){
        pOp->opcode = OP_Sequence;
        pOp->p1 = iAutoidxCur;
      }else{
        pOp->opcode = OP_Null;
        pOp->p1 = 0;
        pOp->p3 = 0;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
cmpb $0x0, 0x61(%rax)
je 0x27c02e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq 0x10(%rdi), %rdi
movl 0x90(%rdi), %r12d
callq 0x26468f
cmpl %r12d, %r15d
jge 0x27c025
cmpl %r14d, 0x4(%rax)
jne 0x27c08b
movzbl (%rax), %ecx
cmpl $0x7f, %ecx
je 0x27c074
cmpl $0x59, %ecx
jne 0x27c08b
movb $0x4d, (%rax)
movl 0x8(%rax), %ecx
addl %ebp, %ecx
movl %ecx, 0x4(%rax)
movl 0xc(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x27c087
testl %ebx, %ebx
je 0x27c080
movb $0x77, (%rax)
movl %ebx, 0x4(%rax)
jmp 0x27c08b
movb $0x48, (%rax)
andl $0x0, 0x4(%rax)
andl $0x0, 0xc(%rax)
incl %r15d
addq $0x18, %rax
jmp 0x27c049
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: explainAppendTerm
static void explainAppendTerm(
  StrAccum *pStr,             /* The text expression being built */
  Index *pIdx,                /* Index to read column names from */
  int nTerm,                  /* Number of terms */
  int iTerm,                  /* Zero-based index of first term. */
  int bAnd,                   /* Non-zero to append " AND " */
  const char *zOp             /* Name of the operator */
){
  int i;

  assert( nTerm>=1 );
  if( bAnd ) sqlite3_str_append(pStr, " AND ", 5);

  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1);
  for(i=0; i<nTerm; i++){
    if( i ) sqlite3_str_append(pStr, ",", 1);
    sqlite3_str_appendall(pStr, explainIndexColumnName(pIdx, iTerm+i));
  }
  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1);

  sqlite3_str_append(pStr, zOp, 1);

  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1);
  for(i=0; i<nTerm; i++){
    if( i ) sqlite3_str_append(pStr, ",", 1);
    sqlite3_str_append(pStr, "?", 1);
  }
  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %ecx, %r15d
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
testl %r8d, %r8d
je 0x27c108
leaq 0xfcdad(%rip), %rsi     # 0x378eaa
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x220f53
cmpl $0x2, %r14d
jl 0x27c120
leaq 0xe4008(%rip), %rsi     # 0x36011d
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x220f53
xorl %r13d, %r13d
testl %r14d, %r14d
movl $0x0, %ebp
movl %r14d, 0xc(%rsp)
cmovgl %r14d, %ebp
pushq $0x1
popq %r14
cmpl %r13d, %ebp
je 0x27c170
testl %r13d, %r13d
je 0x27c154
movq %rbx, %rdi
leaq 0xc52df(%rip), %rsi     # 0x34142b
movl %r14d, %edx
callq 0x220f53
leal (%r15,%r13), %esi
movq %r12, %rdi
callq 0x27c094
movq %rbx, %rdi
movq %rax, %rsi
callq 0x221073
incl %r13d
jmp 0x27c138
cmpl $0x2, 0xc(%rsp)
jl 0x27c1ac
leaq 0xfc382(%rip), %rsi     # 0x378500
pushq $0x1
popq %r14
movq %rbx, %rdi
movl %r14d, %edx
callq 0x220f53
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
callq 0x220f53
leaq 0xe3f79(%rip), %rsi     # 0x36011d
movq %rbx, %rdi
movl %r14d, %edx
jmp 0x27c1b7
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x220f53
xorl %r13d, %r13d
leaq 0x9ac87(%rip), %r14     # 0x316e4d
pushq $0x1
popq %r15
leaq 0xc525a(%rip), %r12     # 0x34142b
cmpl %r13d, %ebp
je 0x27c1fc
testl %r13d, %r13d
je 0x27c1e9
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x220f53
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x220f53
incl %r13d
jmp 0x27c1d1
cmpl $0x2, 0xc(%rsp)
jl 0x27c223
leaq 0xfc2f6(%rip), %rsi     # 0x378500
pushq $0x1
popq %rdx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x220f53
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeExprOrVector
static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){
  assert( nReg>0 );
  if( p && sqlite3ExprIsVector(p) ){
#ifndef SQLITE_OMIT_SUBQUERY
    if( (p->flags & EP_xIsSelect) ){
      Vdbe *v = pParse->pVdbe;
      int iSelect;
      assert( p->op==TK_SELECT );
      iSelect = sqlite3CodeSubselect(pParse, p);
      sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
    }else
#endif
    {
      int i;
      ExprList *pList = p->x.pList;
      assert( nReg<=pList->nExpr );
      for(i=0; i<nReg; i++){
        sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
      }
    }
  }else{
    assert( nReg==1 );
    sqlite3ExprCode(pParse, p, iReg);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
testq %rsi, %rsi
je 0x27c7e7
movl %ecx, %r15d
movq %r12, %rdi
callq 0x2661b9
testl %eax, %eax
je 0x27c7e7
testb $0x8, 0x5(%r12)
jne 0x27c7fd
movq 0x20(%r12), %r12
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
imulq $0x18, %r15, %r15
cmpq %r13, %r15
je 0x27c82a
movq 0x8(%r12,%r13), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x26463f
incl %ebx
addq $0x18, %r13
jmp 0x27c7cb
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x26463f
movq 0x10(%r14), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x26672d
decl %r15d
pushq $0x4d
popq %rsi
movq %r13, %rdi
movl %eax, %edx
movl %ebx, %ecx
movl %r15d, %r8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x24d51f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: disableTerm
static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
  int nLoop = 0;
  assert( pTerm!=0 );
  while( (pTerm->wtFlags & TERM_CODED)==0
      && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
      && (pLevel->notReady & pTerm->prereqAll)==0
  ){
    if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
      pTerm->wtFlags |= TERM_LIKECOND;
    }else{
      pTerm->wtFlags |= TERM_CODED;
    }
    if( pTerm->iParent<0 ) break;
    pTerm = &pTerm->pWC->a[pTerm->iParent];
    assert( pTerm!=0 );
    pTerm->nChild--;
    if( pTerm->nChild!=0 ) break;
    nLoop++;
  }
}

// Assembly:
xorl %eax, %eax
pushq $0x4
popq %rcx
movzwl 0x12(%rsi), %edx
testb $0x4, %dl
jne 0x27c898
cmpl $0x0, (%rdi)
je 0x27c851
movq (%rsi), %r8
testb $0x1, 0x4(%r8)
je 0x27c898
movq 0x38(%rsi), %r8
testq %r8, 0x58(%rdi)
jne 0x27c898
btl $0xa, %edx
movl $0x200, %r8d            # imm = 0x200
cmovael %ecx, %r8d
subl $0x1, %eax
cmovbl %ecx, %r8d
orl %edx, %r8d
movw %r8w, 0x12(%rsi)
movslq 0x18(%rsi), %rdx
testq %rdx, %rdx
js 0x27c898
movq 0x8(%rsi), %rsi
movq 0x20(%rsi), %r8
shlq $0x6, %rdx
leaq (%r8,%rdx), %rsi
decb 0x16(%r8,%rdx)
je 0x27c839
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereLikeOptimizationStringFixup
static void whereLikeOptimizationStringFixup(
  Vdbe *v,                /* prepared statement under construction */
  WhereLevel *pLevel,     /* The loop that contains the LIKE operator */
  WhereTerm *pTerm        /* The upper or lower bound just coded */
){
  if( pTerm->wtFlags & TERM_LIKEOPT ){
    VdbeOp *pOp;
    assert( pLevel->iLikeRepCntr>0 );
    pOp = sqlite3VdbeGetOp(v, -1);
    assert( pOp!=0 );
    assert( pOp->opcode==OP_String8
            || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
    pOp->p3 = (int)(pLevel->iLikeRepCntr>>1);  /* Register holding counter */
    pOp->p5 = (u8)(pLevel->iLikeRepCntr&1);    /* ASC or DESC */
  }
}

// Assembly:
testb $0x1, 0x13(%rdx)
je 0x27c8bd
pushq %rbx
movq %rsi, %rbx
pushq $-0x1
popq %rsi
callq 0x26468f
movl 0x2c(%rbx), %ecx
movl %ecx, %edx
shrl %edx
movl %edx, 0xc(%rax)
andl $0x1, %ecx
movw %cx, 0x2(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: updateRangeAffinityStr
static void updateRangeAffinityStr(
  Expr *pRight,                   /* RHS of comparison */
  int n,                          /* Number of vector elements in comparison */
  char *zAff                      /* Affinity string to modify */
){
  int i;
  for(i=0; i<n; i++){
    Expr *p = sqlite3VectorFieldSubexpr(pRight, i);
    if( sqlite3CompareAffinity(p, zAff[i])==SQLITE_AFF_BLOB
     || sqlite3ExprNeedsNoAffinityChange(p, zAff[i])
    ){
      zAff[i] = SQLITE_AFF_BLOB;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %r14d
cmpq %r12, %r14
je 0x27c918
movq %r15, %rdi
movl %r12d, %esi
callq 0x267cfa
movq %rax, %r13
movsbl (%rbx,%r12), %esi
movq %rax, %rdi
callq 0x267e25
cmpb $0x41, %al
je 0x27c90e
movsbl (%rbx,%r12), %esi
movq %r13, %rdi
callq 0x27c9e8
testl %eax, %eax
je 0x27c913
movb $0x41, (%rbx,%r12)
incq %r12
jmp 0x27c8d9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeApplyAffinity
static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
  Vdbe *v = pParse->pVdbe;
  if( zAff==0 ){
    assert( pParse->db->mallocFailed );
    return;
  }
  assert( v!=0 );

  /* Adjust base and n to skip over SQLITE_AFF_BLOB and SQLITE_AFF_NONE
  ** entries at the beginning and end of the affinity string.
  */
  assert( SQLITE_AFF_NONE<SQLITE_AFF_BLOB );
  while( n>0 && zAff[0]<=SQLITE_AFF_BLOB ){
    n--;
    base++;
    zAff++;
  }
  while( n>1 && zAff[n-1]<=SQLITE_AFF_BLOB ){
    n--;
  }

  /* Code the OP_Affinity opcode if there is anything left to do. */
  if( n>0 ){
    sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
  }
}

// Assembly:
pushq %rax
testq %rcx, %rcx
je 0x27c97b
movq %rcx, %r9
movl %esi, %eax
movq 0x10(%rdi), %rdi
movl %edx, %ecx
sarl $0x1f, %ecx
andl %edx, %ecx
testl %edx, %edx
jle 0x27c94d
cmpb $0x41, (%r9)
jg 0x27c94b
decl %edx
incl %eax
incq %r9
jmp 0x27c938
movl %edx, %ecx
movl %ecx, %edx
movq %rdx, %rcx
cmpl $0x2, %ecx
jl 0x27c965
leaq -0x1(%rcx), %rdx
cmpb $0x42, -0x1(%r9,%rcx)
jl 0x27c94f
jmp 0x27c96b
cmpq $0x1, %rcx
jne 0x27c97b
movl %ecx, (%rsp)
pushq $0x5a
popq %rsi
movl %eax, %edx
xorl %r8d, %r8d
callq 0x264609
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereApplyPartialIndexConstraints
static void whereApplyPartialIndexConstraints(
  Expr *pTruth,
  int iTabCur,
  WhereClause *pWC
){
  int i;
  WhereTerm *pTerm;
  while( pTruth->op==TK_AND ){
    whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC);
    pTruth = pTruth->pRight;
  }
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr;
    if( pTerm->wtFlags & TERM_CODED ) continue;
    pExpr = pTerm->pExpr;
    if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
      pTerm->wtFlags |= TERM_CODED;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x2c, (%r14)
jne 0x27c9a7
movq 0x10(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x27c97d
movq 0x18(%r14), %r14
jmp 0x27c98d
movq 0x20(%rbx), %r15
addq $0x12, %r15
xorl %r12d, %r12d
cmpl 0x14(%rbx), %r12d
jge 0x27c9df
testb $0x4, (%r15)
jne 0x27c9d6
movq -0x12(%r15), %rsi
xorl %edi, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x26823c
testl %eax, %eax
jne 0x27c9d6
orb $0x4, (%r15)
incl %r12d
addq $0x40, %r15
jmp 0x27c9b2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprNeedsNoAffinityChange
SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
  u8 op;
  int unaryMinus = 0;
  if( aff==SQLITE_AFF_BLOB ) return 1;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
    if( p->op==TK_UMINUS ) unaryMinus = 1;
    p = p->pLeft;
  }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_FLOAT: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_STRING: {
      return !unaryMinus && aff==SQLITE_AFF_TEXT;
    }
    case TK_BLOB: {
      return !unaryMinus;
    }
    case TK_COLUMN: {
      assert( p->iTable>=0 );  /* p cannot be part of a CHECK constraint */
      return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0;
    }
    default: {
      return 0;
    }
  }
}

// Assembly:
cmpb $0x41, %sil
jne 0x27c9f2
pushq $0x1
popq %rax
retq
xorl %ecx, %ecx
pushq $0x1
popq %rdx
movb (%rdi), %al
movzbl %al, %r8d
leal -0xaa(%r8), %r9d
cmpl $0x2, %r9d
jae 0x27ca15
cmpb $-0x56, %al
cmovel %edx, %ecx
movq 0x10(%rdi), %rdi
jmp 0x27c9f7
cmpl $0xad, %r8d
jne 0x27ca21
movb 0x2(%rdi), %al
cmpb $0x73, %al
je 0x27ca68
movzbl %al, %edx
cmpl $0x96, %edx
je 0x27ca4a
xorl %eax, %eax
cmpl $0x97, %edx
je 0x27ca62
cmpl $0xa4, %edx
je 0x27ca54
cmpl $0x98, %edx
jne 0x27c9f1
xorl %eax, %eax
cmpb $0x43, %sil
setge %al
retq
cmpb $0x43, %sil
jl 0x27c9f1
movzwl 0x30(%rdi), %eax
shrl $0xf, %eax
retq
testl %ecx, %ecx
sete %al
retq
testl %ecx, %ecx
sete %al
cmpb $0x42, %sil
sete %cl
andb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereIndexExprTransNode
static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
  IdxExprTrans *pX = p->u.pIdxTrans;
  if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
    preserveExpr(pX, pExpr);
    pExpr->affExpr = sqlite3ExprAffinity(pExpr);
    pExpr->op = TK_COLUMN;
    pExpr->iTable = pX->iIdxCur;
    pExpr->iColumn = pX->iIdxCol;
    pExpr->y.pTab = 0;
    testcase( ExprHasProperty(pExpr, EP_Skip) );
    testcase( ExprHasProperty(pExpr, EP_Unlikely) );
    ExprClearProperty(pExpr, EP_Skip|EP_Unlikely);
    return WRC_Prune;
  }else{
    return WRC_Continue;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rdi), %r14
movq (%r14), %rdx
movl 0x8(%r14), %ecx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x26823c
testl %eax, %eax
jne 0x27cad4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27cb4b
movq %rbx, %rdi
callq 0x267d81
movb %al, 0x1(%rbx)
movb $-0x5c, (%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r14), %eax
movw %ax, 0x30(%rbx)
andq $0x0, 0x40(%rbx)
andl $0xfffbefff, 0x4(%rbx)  # imm = 0xFFFBEFFF
pushq $0x1
popq %r15
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereIndexExprTransColumn
static int whereIndexExprTransColumn(Walker *p, Expr *pExpr){
  if( pExpr->op==TK_COLUMN ){
    IdxExprTrans *pX = p->u.pIdxTrans;
    if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){
      assert( pExpr->y.pTab!=0 );
      preserveExpr(pX, pExpr);
      pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn);
      pExpr->iTable = pX->iIdxCur;
      pExpr->iColumn = pX->iIdxCol;
      pExpr->y.pTab = 0;
    }
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x5c, (%rsi)
jne 0x27cb48
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %r14
movl 0x2c(%rsi), %eax
cmpl 0x8(%r14), %eax
jne 0x27cb41
movswl 0x30(%rbx), %eax
cmpl %eax, 0x14(%r14)
jne 0x27cb41
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27cb4b
movswq 0x30(%rbx), %rax
testq %rax, %rax
js 0x27cb27
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movb 0x19(%rcx,%rax), %al
jmp 0x27cb29
movb $0x44, %al
movb %al, 0x1(%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r14), %eax
movw %ax, 0x30(%rbx)
andq $0x0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: preserveExpr
static void preserveExpr(IdxExprTrans *pTrans, Expr *pExpr){
  WhereExprMod *pNew;
  pNew = sqlite3DbMallocRaw(pTrans->db, sizeof(*pNew));
  if( pNew==0 ) return;
  pNew->pNext = pTrans->pWInfo->pExprMods;
  pTrans->pWInfo->pExprMods = pNew;
  pNew->pExpr = pExpr;
  memcpy(&pNew->orig, pExpr, sizeof(*pExpr));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
pushq $0x58
popq %rsi
callq 0x22809f
testq %rax, %rax
je 0x27cb89
movq 0x18(%r14), %rcx
movq 0x58(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x58(%rcx)
movq %rbx, 0x8(%rax)
addq $0x10, %rax
pushq $0x9
popq %rcx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowExprGtZero
static int windowExprGtZero(Parse *pParse, Expr *pExpr){
  int ret = 0;
  sqlite3 *db = pParse->db;
  sqlite3_value *pVal = 0;
  sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
  if( pVal && sqlite3_value_int(pVal)>0 ){
    ret = 1;
  }
  sqlite3ValueFree(pVal);
  return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq %rsp, %rbx
andq $0x0, (%rbx)
movzbl 0x5e(%rdi), %edx
pushq $0x43
popq %rcx
movq %rbx, %r8
callq 0x267878
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x27cc4c
movq %rbx, %rdi
callq 0x224451
xorl %ebp, %ebp
testl %eax, %eax
setg %bpl
jmp 0x27cc4e
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2245fd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq