LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vtabBestIndex
static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
  sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
  int rc;

  whereTraceIndexInfoInputs(p);
  rc = pVtab->pModule->xBestIndex(pVtab, p);
  whereTraceIndexInfoOutputs(p);

  if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
    if( rc==SQLITE_NOMEM ){
      sqlite3OomFault(pParse->db);
    }else if( !pVtab->zErrMsg ){
      sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
    }else{
      sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
    }
  }
  sqlite3_free(pVtab->zErrMsg);
  pVtab->zErrMsg = 0;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40f150
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x452e84
cmpl $0x13, -0x24(%rbp)
je 0x452e84
cmpl $0x7, -0x24(%rbp)
jne 0x452e34
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3c8ba0
jmp 0x452e82
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x452e66
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x3c8a80
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x1491c4(%rip), %rsi    # 0x59c021
movb $0x0, %al
callq 0x3cb660
jmp 0x452e80
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1491a8(%rip), %rsi    # 0x59c021
movb $0x0, %al
callq 0x3cb660
jmp 0x452e82
jmp 0x452e84
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3c0800
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereLoopAdjustCost
static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){
  if( (pTemplate->wsFlags & WHERE_INDEXED)==0 ) return;
  for(; p; p=p->pNextLoop){
    if( p->iTab!=pTemplate->iTab ) continue;
    if( (p->wsFlags & WHERE_INDEXED)==0 ) continue;
    if( whereLoopCheaperProperSubset(p, pTemplate) ){
      /* Adjust pTemplate cost downward so that it is cheaper than its
      ** subset p. */
      WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n",
                       pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut-1));
      pTemplate->rRun = p->rRun;
      pTemplate->nOut = p->nOut - 1;
    }else if( whereLoopCheaperProperSubset(pTemplate, p) ){
      /* Adjust pTemplate cost upward so that it is costlier than p since
      ** pTemplate is a proper subset of p */
      WHERETRACE(0x80,("subset cost adjustment %d,%d to %d,%d\n",
                       pTemplate->rRun, pTemplate->nOut, p->rRun, p->nOut+1));
      pTemplate->rRun = p->rRun;
      pTemplate->nOut = p->nOut + 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x453186
jmp 0x453246
jmp 0x453188
cmpq $0x0, -0x8(%rbp)
je 0x453246
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
cmpl %ecx, %eax
je 0x4531ac
jmp 0x453235
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x4531bf
jmp 0x453235
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4536a0
cmpl $0x0, %eax
je 0x4531f9
movq -0x8(%rbp), %rax
movw 0x14(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x8(%rbp), %rax
movswl 0x16(%rax), %eax
subl $0x1, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x16(%rax)
jmp 0x453233
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4536a0
cmpl $0x0, %eax
je 0x453231
movq -0x8(%rbp), %rax
movw 0x14(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x8(%rbp), %rax
movswl 0x16(%rax), %eax
addl $0x1, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x16(%rax)
jmp 0x453233
jmp 0x453235
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x453188
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2c(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2e(%rcx), %ecx
subl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x2c(%rcx), %ecx
movq -0x18(%rbp), %rdx
movzwl 0x2e(%rdx), %edx
subl %edx, %ecx
cmpl %ecx, %eax
jl 0x4536e0
movl $0x0, -0x4(%rbp)
jmp 0x45380e
movq -0x18(%rbp), %rax
movzwl 0x2e(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2e(%rcx), %ecx
cmpl %ecx, %eax
jle 0x453700
movl $0x0, -0x4(%rbp)
jmp 0x45380e
movq -0x10(%rbp), %rax
movswl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x14(%rcx), %ecx
cmpl %ecx, %eax
jl 0x453756
movq -0x10(%rbp), %rax
movswl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x14(%rcx), %ecx
cmpl %ecx, %eax
jle 0x453734
movl $0x0, -0x4(%rbp)
jmp 0x45380e
movq -0x10(%rbp), %rax
movswl 0x16(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x16(%rcx), %ecx
cmpl %ecx, %eax
jle 0x453754
movl $0x0, -0x4(%rbp)
jmp 0x45380e
jmp 0x453756
movq -0x10(%rbp), %rax
movzwl 0x2c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x4537e0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x45377f
jmp 0x4537d5
movq -0x18(%rbp), %rax
movzwl 0x2c(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x4537c4
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x4537b7
jmp 0x4537c4
jmp 0x4537b9
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x45378d
cmpl $0x0, -0x20(%rbp)
jge 0x4537d3
movl $0x0, -0x4(%rbp)
jmp 0x45380e
jmp 0x4537d5
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x453764
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x453807
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x453807
movl $0x0, -0x4(%rbp)
jmp 0x45380e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x40(%rcx), %eax
je 0x453950
movl $0x0, -0x4(%rbp)
jmp 0x453a1f
movq -0x10(%rbp), %rax
movzwl 0x14(%rax), %eax
andl $0x82, %eax
cmpl $0x0, %eax
jne 0x45396e
movl $0x0, -0x4(%rbp)
jmp 0x453a1f
movq -0x18(%rbp), %rax
movzbl 0x3c(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4539ab
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4539ab
movq -0x10(%rbp), %rax
movzwl 0x14(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4539ab
movl $0x0, -0x4(%rbp)
jmp 0x453a1f
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x4539c6
movl $0x0, -0x4(%rbp)
jmp 0x453a1f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jge 0x4539d9
movl $0x0, -0x4(%rbp)
jmp 0x453a1f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movb 0x19(%rax), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movsbl -0x21(%rbp), %esi
callq 0x450cf0
cmpl $0x0, %eax
jne 0x453a18
movl $0x0, -0x4(%rbp)
jmp 0x453a1f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x453a96
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x453a30
cmpl $0x0, %eax
jne 0x453a88
movl $0x0, -0x4(%rbp)
jmp 0x453b55
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x453a54
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
andq $0x800000, %rax         # imm = 0x800000
cmpq $0x0, %rax
je 0x453ab5
movq $0x0, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x453b4e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x453afb
movq -0x40(%rbp), %rax
movswl 0x34(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x453b32
cmpl $0x0, -0xc(%rbp)
je 0x453b10
movq -0x40(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x453b32
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x8(%rbp), %ecx
callq 0x430570
cmpl $0x0, %eax
je 0x453b32
movl $0x1, -0x4(%rbp)
jmp 0x453b55
jmp 0x453b34
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x30(%rbp)
jmp 0x453ac8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19360
movl -0xc(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0xcb8(%rip), %rax       # 0x454c30
movq %rax, -0x40(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x42f650
cmpw $0x0, -0x24(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa4, %eax
jne 0x454c93
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jne 0x454c93
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movswl 0x30(%rax), %esi
callq 0x42e800
cwtl
cmpl $0x0, %eax
jge 0x454c93
movq -0x10(%rbp), %rax
movw $0x1, 0x24(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x454c9a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereRangeAdjust
static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
  LogEst nRet = nNew;
  if( pTerm ){
    if( pTerm->truthProb<=0 ){
      nRet += pTerm->truthProb;
    }else if( (pTerm->wtFlags & TERM_VNULL)==0 ){
      nRet -= 20;        assert( 20==sqlite3LogEst(4) );
    }
  }
  return nRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x454ffe
movq -0x8(%rbp), %rax
movswl 0x10(%rax), %eax
cmpl $0x0, %eax
jg 0x454fdf
movq -0x8(%rbp), %rax
movswl 0x10(%rax), %ecx
movswl -0xc(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xc(%rbp)
jmp 0x454ffc
movq -0x8(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x0, %eax
cmpl $0x0, %eax
jne 0x454ffa
movswl -0xc(%rbp), %eax
subl $0x14, %eax
movw %ax, -0xc(%rbp)
jmp 0x454ffc
jmp 0x454ffe
movw -0xc(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereSortingCost
static LogEst whereSortingCost(
  WhereInfo *pWInfo,
  LogEst nRow,
  int nOrderBy,
  int nSorted
){
  /* TUNING: Estimated cost of a full external sort, where N is
  ** the number of rows to sort is:
  **
  **   cost = (3.0 * N * log(N)).
  **
  ** Or, if the order-by clause has X terms but only the last Y
  ** terms are out of order, then block-sorting will reduce the
  ** sorting cost to:
  **
  **   cost = (3.0 * N * log(N)) * (Y/X)
  **
  ** The (Y/X) term is implemented using stack variable rScale
  ** below.  */
  LogEst rScale, rSortCost;
  assert( nOrderBy>0 && 66==sqlite3LogEst(100) );
  rScale = sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;
  rSortCost = nRow + rScale + 16;

  /* Multiple by log(M) where M is the number of output rows.
  ** Use the LIMIT for M if it is smaller */
  if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 && pWInfo->iLimit<nRow ){
    nRow = pWInfo->iLimit;
  }
  rSortCost += estLog(nRow);
  return rSortCost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %eax
subl -0x14(%rbp), %eax
imull $0x64, %eax, %eax
cltd
idivl -0x10(%rbp)
movslq %eax, %rdi
callq 0x3fcec0
cwtl
subl $0x42, %eax
movw %ax, -0x16(%rbp)
movswl -0xa(%rbp), %eax
movswl -0x16(%rbp), %ecx
addl %ecx, %eax
addl $0x10, %eax
movw %ax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x3c(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x455ba5
movq -0x8(%rbp), %rax
movswl 0x3e(%rax), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0x455ba5
movq -0x8(%rbp), %rax
movw 0x3e(%rax), %ax
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %edi
callq 0x4538e0
movswl %ax, %ecx
movswl -0x18(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x18(%rbp)
movw -0x18(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x429e10
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x430ae0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x61(%rax)
je 0x455c23
jmp 0x455ce3
jmp 0x455c25
movl -0xc(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x455ce3
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
je 0x455c42
jmp 0x455cc9
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x59, %eax
jne 0x455c81
movq -0x28(%rbp), %rax
movb $0x4d, (%rax)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
addl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x455cc7
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jne 0x455cc5
cmpl $0x0, -0x18(%rbp)
je 0x455ca6
movq -0x28(%rbp), %rax
movb $0x77, (%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x455cc3
movq -0x28(%rbp), %rax
movb $0x48, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x455cc5
jmp 0x455cc7
jmp 0x455cc9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
jmp 0x455c25
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: explainIndexRange
static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){
  Index *pIndex = pLoop->u.btree.pIndex;
  u16 nEq = pLoop->u.btree.nEq;
  u16 nSkip = pLoop->nSkip;
  int i, j;

  if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return;
  sqlite3_str_append(pStr, " (", 2);
  for(i=0; i<nEq; i++){
    const char *z = explainIndexColumnName(pIndex, i);
    if( i ) sqlite3_str_append(pStr, " AND ", 5);
    sqlite3_str_appendf(pStr, i>=nSkip ? "%s=?" : "ANY(%s)", z);
  }

  j = i;
  if( pLoop->wsFlags&WHERE_BTM_LIMIT ){
    explainAppendTerm(pStr, pIndex, pLoop->u.btree.nBtm, j, i, ">");
    i = 1;
  }
  if( pLoop->wsFlags&WHERE_TOP_LIMIT ){
    explainAppendTerm(pStr, pIndex, pLoop->u.btree.nTop, j, i, "<");
  }
  sqlite3_str_append(pStr, ")", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw 0x18(%rax), %ax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movw 0x2e(%rax), %ax
movw %ax, -0x1c(%rbp)
movzwl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jne 0x455d41
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x30, %eax
cmpl $0x0, %eax
jne 0x455d41
jmp 0x455e4e
movq -0x8(%rbp), %rdi
leaq 0x13d111(%rip), %rsi    # 0x592e5d
movl $0x2, %edx
callq 0x3c2d40
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x455dc8
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x455e60
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x455d93
movq -0x8(%rbp), %rdi
leaq 0x15819b(%rip), %rsi    # 0x5adf24
movl $0x5, %edx
callq 0x3c2d40
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %ecx
movzwl -0x1c(%rbp), %edx
leaq 0x15818a(%rip), %rsi    # 0x5adf2f
leaq 0x15817e(%rip), %rax    # 0x5adf2a
cmpl %edx, %ecx
cmovgeq %rax, %rsi
movq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x3c3ac0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x455d5d
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x455e07
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movzwl 0x1a(%rax), %edx
movl -0x24(%rbp), %ecx
movl -0x20(%rbp), %r8d
leaq 0x13faa7(%rip), %r9     # 0x5958a2
callq 0x455ed0
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x455e39
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movzwl 0x1c(%rax), %edx
movl -0x24(%rbp), %ecx
movl -0x20(%rbp), %r8d
leaq 0x1580ad(%rip), %r9     # 0x5adee1
callq 0x455ed0
movq -0x8(%rbp), %rdi
leaq 0x157736(%rip), %rsi    # 0x5ad57a
movl $0x1, %edx
callq 0x3c2d40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: explainIndexColumnName
static const char *explainIndexColumnName(Index *pIdx, int i){
  i = pIdx->aiColumn[i];
  if( i==XN_EXPR ) return "<expr>";
  if( i==XN_ROWID ) return "rowid";
  return pIdx->pTable->aCol[i].zName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
movl %eax, -0x14(%rbp)
cmpl $-0x2, -0x14(%rbp)
jne 0x455e91
leaq 0x1580ac(%rip), %rax    # 0x5adf37
movq %rax, -0x8(%rbp)
jmp 0x455ec2
cmpl $-0x1, -0x14(%rbp)
jne 0x455ea4
leaq 0x155b55(%rip), %rax    # 0x5ab9f3
movq %rax, -0x8(%rbp)
jmp 0x455ec2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x455f09
movq -0x8(%rbp), %rdi
leaq 0x158025(%rip), %rsi    # 0x5adf24
movl $0x5, %edx
callq 0x3c2d40
cmpl $0x1, -0x14(%rbp)
jle 0x455f24
movq -0x8(%rbp), %rdi
leaq 0x13cf44(%rip), %rsi    # 0x592e5e
movl $0x1, %edx
callq 0x3c2d40
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x455f7c
cmpl $0x0, -0x2c(%rbp)
je 0x455f4e
movq -0x8(%rbp), %rdi
leaq 0x11d7af(%rip), %rsi    # 0x5736f3
movl $0x1, %edx
callq 0x3c2d40
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
addl -0x2c(%rbp), %esi
callq 0x455e60
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3c3170
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x455f2b
cmpl $0x1, -0x14(%rbp)
jle 0x455f97
movq -0x8(%rbp), %rdi
leaq 0x1575ed(%rip), %rsi    # 0x5ad57a
movl $0x1, %edx
callq 0x3c2d40
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x3c2d40
cmpl $0x1, -0x14(%rbp)
jle 0x455fc4
movq -0x8(%rbp), %rdi
leaq 0x13cea4(%rip), %rsi    # 0x592e5e
movl $0x1, %edx
callq 0x3c2d40
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x45600e
cmpl $0x0, -0x2c(%rbp)
je 0x455fee
movq -0x8(%rbp), %rdi
leaq 0x11d70f(%rip), %rsi    # 0x5736f3
movl $0x1, %edx
callq 0x3c2d40
movq -0x8(%rbp), %rdi
leaq 0xf2de9(%rip), %rsi     # 0x548de2
movl $0x1, %edx
callq 0x3c2d40
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x455fcb
cmpl $0x1, -0x14(%rbp)
jle 0x456029
movq -0x8(%rbp), %rdi
leaq 0x15755b(%rip), %rsi    # 0x5ad57a
movl $0x1, %edx
callq 0x3c2d40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4565fd
movq -0x10(%rbp), %rdi
callq 0x42c210
cmpl $0x0, %eax
je 0x4565fd
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x4565ae
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42d160
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
subl $0x1, %r8d
movl $0x4d, %esi
callq 0x410130
jmp 0x4565fb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4565f9
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
addq $0x8, %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
addl -0x28(%rbp), %edx
callq 0x429d30
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4565c1
jmp 0x4565fb
jmp 0x45660d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x429d30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %ecx
andl $0x4, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jne 0x456682
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x456668
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x456682
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
andq 0x38(%rcx), %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x45668e
jmp 0x45671e
cmpl $0x0, -0x14(%rbp)
je 0x4566ba
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x4566ba
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movw %cx, 0x12(%rax)
jmp 0x4566c9
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x12(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jge 0x4566d5
jmp 0x45671e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x16(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x16(%rax)
movq -0x10(%rbp), %rax
movzbl 0x16(%rax), %eax
cmpl $0x0, %eax
je 0x456710
jmp 0x45671e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x456633
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x456aa0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x429e10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %ecx
shrl %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
andl $0x1, %eax
movzbl %al, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x2(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x456b32
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x42f090
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x42f370
movsbl %al, %eax
cmpl $0x41, %eax
je 0x456b19
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x4572d0
cmpl $0x0, %eax
je 0x456b25
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x41, (%rax,%rcx)
jmp 0x456b27
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x456aca
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x456b6e
jmp 0x456c16
jmp 0x456b70
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
jle 0x456b8b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x456b94
jmp 0x456bb4
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x456b70
jmp 0x456bb6
xorl %eax, %eax
cmpl $0x1, -0x10(%rbp)
movb %al, -0x22(%rbp)
jle 0x456bdb
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
setle %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x456be4
jmp 0x456bef
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x456bb6
cmpl $0x0, -0x10(%rbp)
jle 0x456c16
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %r9
movl -0x10(%rbp), %eax
movl $0x5a, %esi
xorl %r8d, %r8d
movl %eax, (%rsp)
callq 0x429aa0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x456fd1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x456f90
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x456fa3
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x45704e
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x457002
jmp 0x457037
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x42fc30
cmpl $0x0, %eax
jne 0x457035
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x12(%rax)
jmp 0x457037
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
jmp 0x456fe4
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x41, %eax
jne 0x4572fa
movl $0x1, -0x4(%rbp)
jmp 0x457429
jmp 0x4572fc
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0xab, %ecx
movb %al, -0x19(%rbp)
je 0x457322
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xaa, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x45732b
jmp 0x45734e
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xaa, %eax
jne 0x457340
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4572fc
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0xad, %eax
jne 0x45736c
movq -0x10(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
addl $-0x73, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x31, %eax
ja 0x457422
movq -0x28(%rbp), %rax
leaq 0x14f143(%rip), %rcx    # 0x5a64d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl -0x11(%rbp), %eax
cmpl $0x43, %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x457429
movsbl -0x11(%rbp), %eax
cmpl $0x43, %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x457429
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
jne 0x4573d6
movsbl -0x11(%rbp), %eax
cmpl $0x42, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x457429
cmpl $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x457429
movsbl -0x11(%rbp), %ecx
xorl %eax, %eax
cmpl $0x43, %ecx
movb %al, -0x2a(%rbp)
jl 0x457415
movq -0x10(%rbp), %rax
movswl 0x30(%rax), %eax
cmpl $0x0, %eax
setl %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x457429
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x42fc30
cmpl $0x0, %eax
jne 0x4574d7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4575a0
movq -0x18(%rbp), %rdi
callq 0x42f230
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movb $-0x5c, (%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xfffbefff, %ecx       # imm = 0xFFFBEFFF
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4574de
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa4, %eax
jne 0x457598
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x457596
movq -0x10(%rbp), %rax
movswl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x457596
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4575a0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movswl 0x30(%rax), %esi
callq 0x42baa0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x457598
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x58, %esi
callq 0x3cd3a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4575cf
jmp 0x457614
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movl $0x48, %edx
callq 0x19610
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movl $0x43, %ecx
leaq -0x28(%rbp), %r8
movzbl 0x5e(%rax), %edx
callq 0x42e940
cmpq $0x0, -0x28(%rbp)
je 0x4577d4
movq -0x28(%rbp), %rdi
callq 0x3c7a40
cmpl $0x0, %eax
jle 0x4577d4
movl $0x1, -0x14(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3c7ef0
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowCacheFrame
static int windowCacheFrame(Window *pMWin){
  Window *pWin;
  if( pMWin->regStartRowid ) return 1;
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *pFunc = pWin->pFunc;
    if( (pFunc->zName==nth_valueName)
     || (pFunc->zName==first_valueName)
     || (pFunc->zName==leadName)
     || (pFunc->zName==lagName)
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x84(%rax)
je 0x45780e
movl $0x1, -0x4(%rbp)
jmp 0x45788d
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x457886
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x152f5c(%rip), %rcx    # 0x5aa790
cmpq %rcx, 0x38(%rax)
je 0x45786d
movq -0x20(%rbp), %rax
leaq 0x152f55(%rip), %rcx    # 0x5aa79a
cmpq %rcx, 0x38(%rax)
je 0x45786d
movq -0x20(%rbp), %rax
leaq 0x152f04(%rip), %rcx    # 0x5aa75a
cmpq %rcx, 0x38(%rax)
je 0x45786d
movq -0x20(%rbp), %rax
leaq 0x152ef8(%rip), %rcx    # 0x5aa75f
cmpq %rcx, 0x38(%rax)
jne 0x457876
movl $0x1, -0x4(%rbp)
jmp 0x45788d
jmp 0x457878
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x457816
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)