LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CreateColumnExpr
SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
  Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
  if( p ){
    struct SrcList_item *pItem = &pSrc->a[iSrc];
    Table *pTab = p->y.pTab = pItem->pTab;
    p->iTable = pItem->iCursor;
    if( p->y.pTab->iPKey==iCol ){
      p->iColumn = -1;
    }else{
      p->iColumn = (ynVar)iCol;
      if( (pTab->tabFlags & TF_HasGenerated)!=0
       && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
      ){
        testcase( pTab->nCol==63 );
        testcase( pTab->nCol==64 );
        pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
      }else{
        testcase( iCol==BMS );
        testcase( iCol==BMS-1 );
        pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
      }
    }
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movl $0x48, %esi
callq 0x282a35
testq %rax, %rax
je 0x2c94c6
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x40(%rax)
movb $-0x5c, (%rax)
movw $0xffff, 0x32(%rax)     # imm = 0xFFFF
movl $0x1, 0x28(%rax)
movslq %ebp, %rcx
imulq $0x70, %rcx, %rdx
movq 0x28(%r14,%rdx), %rcx
movq %rcx, 0x40(%rax)
movl 0x48(%r14,%rdx), %esi
movl %esi, 0x2c(%rax)
movswl 0x44(%rcx), %esi
cmpl %ebx, %esi
jne 0x2c9466
movw $0xffff, 0x30(%rax)     # imm = 0xFFFF
jmp 0x2c94c6
addq %r14, %rdx
addq $0x8, %rdx
movw %bx, 0x30(%rax)
testb $0x60, 0x40(%rcx)
je 0x2c94af
movq 0x8(%rcx), %rsi
movslq %ebx, %rdi
shlq $0x5, %rdi
testb $0x60, 0x1c(%rsi,%rdi)
je 0x2c94af
movzwl 0x46(%rcx), %ecx
movq $-0x1, %rsi
movq $-0x1, %rdi
shlq %cl, %rdi
cmpw $0x40, %cx
notq %rdi
cmovgeq %rsi, %rdi
movq %rdi, 0x58(%rdx)
jmp 0x2c94c6
cmpl $0x3f, %ebx
movl $0x3f, %ecx
cmovll %ebx, %ecx
movl $0x1, %esi
shlq %cl, %rsi
orq %rsi, 0x58(%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resolveAsName
static int resolveAsName(
  Parse *pParse,     /* Parsing context for error messages */
  ExprList *pEList,  /* List of expressions to scan */
  Expr *pE           /* Expression we are trying to match */
){
  int i;             /* Loop counter */

  UNUSED_PARAMETER(pParse);

  if( pE->op==TK_ID ){
    char *zCol = pE->u.zToken;
    for(i=0; i<pEList->nExpr; i++){
      if( pEList->a[i].eEName==ENAME_NAME
       && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
      ){
        return i+1;
      }
    }
  }
  return 0;
}

// Assembly:
xorl %eax, %eax
cmpb $0x3b, (%rsi)
jne 0x2c95b3
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x2c95b3
movq 0x8(%rsi), %rdx
addq $0x8, %rdi
xorl %eax, %eax
leaq 0x107d84(%rip), %rsi    # 0x3d12e0
leaq (%rax,%rax,2), %r8
testb $0x3, 0x11(%rdi,%r8,8)
je 0x2c9572
incq %rax
cmpq %rcx, %rax
jne 0x2c955c
jmp 0x2c95b4
leaq (%rdi,%r8,8), %r8
movq 0x8(%r8), %r8
testq %r8, %r8
je 0x2c95ac
testq %rdx, %rdx
je 0x2c9568
xorl %r9d, %r9d
movzbl (%r8,%r9), %r10d
movzbl (%rdx,%r9), %r11d
cmpb %r11b, %r10b
jne 0x2c959d
testq %r10, %r10
jne 0x2c95a7
jmp 0x2c95b1
movb (%r10,%rsi), %r10b
cmpb (%r11,%rsi), %r10b
jne 0x2c9568
incq %r9
jmp 0x2c9587
testq %rdx, %rdx
jne 0x2c9568
incl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resolveRemoveWindowsCb
static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
  UNUSED_PARAMETER(pWalker);
  if( ExprHasProperty(pExpr, EP_WinFunc) ){
    Window *pWin = pExpr->y.pWin;
    sqlite3WindowUnlinkFromSelect(pWin);
  }
  return WRC_Continue;
}

// Assembly:
testb $0x1, 0x7(%rsi)
je 0x2c971b
movq 0x40(%rsi), %rax
movq 0x38(%rax), %rdx
testq %rdx, %rdx
je 0x2c971b
movq 0x40(%rax), %rcx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x2c9713
movq 0x38(%rax), %rdx
movq %rdx, 0x38(%rcx)
movq $0x0, 0x38(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3Dequote
SQLITE_PRIVATE void sqlite3Dequote(char *z){
  char quote;
  int i, j;
  if( z==0 ) return;
  quote = z[0];
  if( !sqlite3Isquote(quote) ) return;
  if( quote=='[' ) quote = ']';
  for(i=1, j=0;; i++){
    assert( z[i] );
    if( z[i]==quote ){
      if( z[i+1]==quote ){
        z[j++] = quote;
        i++;
      }else{
        break;
      }
    }else{
      z[j++] = z[i];
    }
  }
  z[j] = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2c9832
movzbl (%rdi), %eax
leaq 0x107c14(%rip), %rcx    # 0x3d1440
cmpb $0x0, (%rax,%rcx)
js 0x2c9833
retq
cmpb $0x5b, %al
movzbl %al, %ecx
movl $0x5d, %eax
cmovnel %ecx, %eax
movl $0x1, %edx
xorl %ecx, %ecx
movslq %edx, %rsi
movb (%rdi,%rsi), %r8b
cmpb %al, %r8b
jne 0x2c9861
cmpb %al, 0x1(%rdi,%rsi)
jne 0x2c986c
incq %rsi
movl %eax, %r8d
movl %esi, %edx
movb %r8b, (%rdi,%rcx)
incq %rcx
incl %edx
jmp 0x2c9847
movl %ecx, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DbSpanDup
SQLITE_PRIVATE char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){
  int n;
  while( sqlite3Isspace(zStart[0]) ) zStart++;
  n = (int)(zEnd - zStart);
  while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--;
  return sqlite3DbStrNDup(db, zStart, n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subl %esi, %edx
leaq 0x107bbf(%rip), %rax    # 0x3d1440
movq %rsi, %rbx
movl %edx, %r8d
movzbl (%rsi), %ecx
incq %rsi
leal -0x1(%r8), %edx
testb $0x1, (%rcx,%rax)
jne 0x2c9881
movl %r8d, %ecx
movslq %r8d, %rdx
movq %rdx, %r14
testl %ecx, %ecx
jle 0x2c98b8
movzbl -0x2(%rsi,%rcx), %r8d
decq %rcx
leaq -0x1(%r14), %rdx
testb $0x1, (%r8,%rax)
jne 0x2c989d
leaq 0x1(%r14), %rsi
callq 0x282a35
movq %rax, %r15
testq %rax, %rax
je 0x2c98dc
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x17660
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RenameExprUnmap
SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
  u8 eMode = pParse->eParseMode;
  Walker sWalker;
  memset(&sWalker, 0, sizeof(Walker));
  sWalker.pParse = pParse;
  sWalker.xExprCallback = renameUnmapExprCb;
  sWalker.xSelectCallback = renameUnmapSelectCb;
  pParse->eParseMode = PARSE_MODE_UNMAP;
  sqlite3WalkExpr(&sWalker, pExpr);
  pParse->eParseMode = eMode;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb 0x11c(%rdi), %bpl
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x35(%rip), %rax        # 0x2c9947
movq %rax, 0x10(%rsp)
leaq 0x4d(%rip), %rax        # 0x2c996b
movq %rax, 0x18(%rsp)
movb $0x3, 0x11c(%rdi)
testq %rsi, %rsi
je 0x2c9939
leaq 0x8(%rsp), %rdi
callq 0x2c0a8c
movb %bpl, 0x11c(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameUnmapSelectCb
static int renameUnmapSelectCb(Walker *pWalker, Select *p){
  Parse *pParse = pWalker->pParse;
  int i;
  if( pParse->nErr ) return WRC_Abort;
  if( NEVER(p->selFlags & SF_View) ) return WRC_Prune;
  if( ALWAYS(p->pEList) ){
    ExprList *pList = p->pEList;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].zEName && pList->a[i].eEName==ENAME_NAME ){
        sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);
      }
    }
  }
  if( ALWAYS(p->pSrc) ){  /* Every Select as a SrcList, even if it is empty */
    SrcList *pSrc = p->pSrc;
    for(i=0; i<pSrc->nSrc; i++){
      sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
      if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort;
      unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);
    }
  }

  renameWalkWith(pWalker, p);
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
cmpl $0x0, 0x30(%r15)
je 0x2c998a
movl $0x2, %eax
jmp 0x2c9acf
movl $0x1, %eax
testb $0x20, 0x6(%rsi)
jne 0x2c9acf
movq %rdi, %rbx
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x2c99f5
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x2c99f5
addq $0x8, %rax
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
movq 0x8(%rax,%rdi,8), %r8
testq %r8, %r8
je 0x2c99cb
leaq (%rax,%rdi,8), %rdi
testb $0x3, 0x11(%rdi)
je 0x2c99d5
incq %rdx
cmpq %rcx, %rdx
jne 0x2c99b3
jmp 0x2c99f5
movq 0x1a0(%r15), %rdi
testq %rdi, %rdi
je 0x2c99cb
cmpq %r8, (%rdi)
je 0x2c99ec
movq 0x18(%rdi), %rdi
jmp 0x2c99dc
movq $0x0, (%rdi)
jmp 0x2c99cb
movq %rsi, (%rsp)
movq 0x28(%rsi), %r12
testq %r12, %r12
je 0x2c9abd
cmpl $0x0, (%r12)
jle 0x2c9abd
leaq 0x8(%r12), %r13
xorl %ebp, %ebp
imulq $0x70, %rbp, %r14
movq 0x1a0(%r15), %rax
testq %rax, %rax
je 0x2c9a44
movq 0x10(%r13,%r14), %rcx
cmpq %rcx, (%rax)
je 0x2c9a3d
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x2c9a2d
jmp 0x2c9a44
movq $0x0, (%rax)
addq %r13, %r14
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x2c9a60
movq %rbx, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c9980
movq 0x50(%r14), %rcx
testq %rcx, %rcx
je 0x2c9aad
movslq 0x8(%rcx), %rax
testq %rax, %rax
jle 0x2c9aad
movq (%rcx), %rcx
xorl %edx, %edx
movq 0x1a0(%r15), %rsi
testq %rsi, %rsi
je 0x2c9aa5
movq %rdx, %rdi
shlq $0x4, %rdi
movq (%rcx,%rdi), %rdi
cmpq %rdi, (%rsi)
je 0x2c9a9e
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
jne 0x2c9a8e
jmp 0x2c9aa5
movq $0x0, (%rsi)
incq %rdx
cmpq %rax, %rdx
jne 0x2c9a77
incq %rbp
movslq (%r12), %rax
cmpq %rax, %rbp
jl 0x2c9a18
movq (%rsp), %rax
movq 0x68(%rax), %rsi
movq %rbx, %rdi
callq 0x2c9ade
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameWalkWith
static void renameWalkWith(Walker *pWalker, Select *pSelect){
  With *pWith = pSelect->pWith;
  if( pWith ){
    int i;
    for(i=0; i<pWith->nCte; i++){
      Select *p = pWith->a[i].pSelect;
      NameContext sNC;
      memset(&sNC, 0, sizeof(sNC));
      sNC.pParse = pWalker->pParse;
      sqlite3SelectPrep(sNC.pParse, p, &sNC);
      sqlite3WalkSelect(pWalker, p);
      sqlite3RenameExprlistUnmap(pWalker->pParse, pWith->a[i].pCols);
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2c9b68
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
cmpl $0x0, (%rsi)
jle 0x2c9b5a
movq %rdi, %r14
leaq 0x8(%rsp), %r13
leaq 0x20(%rbx), %rbp
xorl %r15d, %r15d
movq (%rbp), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
movq (%r14), %rdi
movq %rdi, (%rsp)
movq %r12, %rsi
movq %rsp, %rdx
callq 0x2c6ee7
movq %r14, %rdi
movq %r12, %rsi
callq 0x2c0b5b
movq (%r14), %rdi
movq -0x8(%rbp), %rsi
callq 0x2c9b69
incq %r15
movslq (%rbx), %rax
addq $0x20, %rbp
cmpq %rax, %r15
jl 0x2c9b0c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RenameExprlistUnmap
SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){
  if( pEList ){
    int i;
    Walker sWalker;
    memset(&sWalker, 0, sizeof(Walker));
    sWalker.pParse = pParse;
    sWalker.xExprCallback = renameUnmapExprCb;
    sqlite3WalkExprList(&sWalker, pEList);
    for(i=0; i<pEList->nExpr; i++){
      if( ALWAYS(pEList->a[i].eEName==ENAME_NAME) ){
        sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName);
      }
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2c9bf9
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdi
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq %r14, (%rdi)
leaq -0x252(%rip), %rax      # 0x2c9947
movq %rax, 0x8(%rdi)
callq 0x2c0cc0
movslq (%rbx), %rax
testq %rax, %rax
jle 0x2c9bf2
addq $0x8, %rbx
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rsi
testb $0x3, 0x11(%rbx,%rsi,8)
je 0x2c9bc5
incq %rcx
cmpq %rax, %rcx
jne 0x2c9bb0
jmp 0x2c9bf2
movq 0x1a0(%r14), %rdx
testq %rdx, %rdx
je 0x2c9bbb
leaq (%rbx,%rsi,8), %rsi
movq 0x8(%rsi), %rsi
cmpq %rsi, (%rdx)
je 0x2c9be9
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
jne 0x2c9bd9
jmp 0x2c9bbb
movq $0x0, (%rdx)
jmp 0x2c9bbb
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3HasExplicitNulls
SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
  if( pList ){
    int i;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].bNulls ){
        u8 sf = pList->a[i].sortFlags;
        sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
            (sf==0 || sf==3) ? "FIRST" : "LAST"
        );
        return 1;
      }
    }
  }
  return 0;
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x2c9c5c
movslq (%rsi), %rcx
testq %rcx, %rcx
jle 0x2c9c5c
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %eax, %eax
testb $0x20, 0x19(%rsi,%rax)
jne 0x2c9c26
addq $0x18, %rax
cmpq %rax, %rcx
jne 0x2c9c13
xorl %eax, %eax
retq
pushq %rax
movb 0x18(%rsi,%rax), %al
cmpb $0x3, %al
leaq 0x10e5f3(%rip), %rcx    # 0x3d8227
leaq 0x8697c(%rip), %rdx     # 0x3505b7
cmoveq %rcx, %rdx
testb %al, %al
cmoveq %rcx, %rdx
leaq 0x10e5bf(%rip), %rsi    # 0x3d820b
xorl %eax, %eax
callq 0x27b48d
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListLookup
SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
  struct SrcList_item *pItem = pSrc->a;
  Table *pTab;
  assert( pItem && pSrc->nSrc>=1 );
  pTab = sqlite3LocateTableItem(pParse, 0, pItem);
  sqlite3DeleteTable(pParse->db, pItem->pTab);
  pItem->pTab = pTab;
  if( pTab ){
    pTab->nTabRef++;
  }
  if( sqlite3IndexedByLookup(pParse, pItem) ){
    pTab = 0;
  }
  return pTab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rsi), %r14
xorl %esi, %esi
movq %r14, %rdx
callq 0x2c84c3
movq %rax, %rbx
movq (%r15), %rdi
movq 0x28(%r12), %rsi
callq 0x272447
movq %rbx, 0x28(%r12)
testq %rbx, %rbx
je 0x2c9c96
incl 0x3c(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c87e8
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rbx, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FixSrcList
SQLITE_PRIVATE int sqlite3FixSrcList(
  DbFixer *pFix,       /* Context of the fixation */
  SrcList *pList       /* The Source list to check and modify */
){
  int i;
  struct SrcList_item *pItem;
  sqlite3 *db = pFix->pParse->db;
  int iDb = sqlite3FindDbName(db, pFix->zDb);

  if( NEVER(pList==0) ) return 0;

  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
    if( pFix->bTemp==0 ){
      if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
        sqlite3ErrorMsg(pFix->pParse,
            "%s %T cannot reference objects in database %s",
            pFix->zType, pFix->pName, pItem->zDatabase);
        return 1;
      }
      sqlite3DbFree(db, pItem->zDatabase);
      pItem->zDatabase = 0;
      pItem->pSchema = pFix->pSchema;
      pItem->fg.fromDDL = 1;
    }
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
#endif
    if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rdi), %rsi
movq (%rax), %r15
movq %r15, %rdi
callq 0x280170
xorl %r12d, %r12d
testq %r14, %r14
je 0x2c9dee
cmpl $0x0, (%r14)
jle 0x2c9dee
movl %eax, 0x4(%rsp)
movq %r15, 0x8(%rsp)
leaq 0x8(%r14), %r13
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
cmpb $0x0, 0x10(%rbx)
jne 0x2c9d51
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x2c9d3c
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x280170
cmpl %eax, 0x4(%rsp)
jne 0x2c9dcc
movq %r15, %rdi
movq %r12, %rsi
callq 0x282904
movq $0x0, 0x8(%r13)
movq 0x8(%rbx), %rax
movq %rax, (%r13)
orb $0x40, 0x3d(%r13)
movq 0x28(%r13), %rsi
movq %rbx, %rdi
callq 0x2ca34d
movl $0x1, %r12d
testl %eax, %eax
jne 0x2c9dee
movq 0x48(%r13), %rsi
movq %rbx, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2c9dee
testb $0x4, 0x3d(%r13)
je 0x2c9db3
movq 0x60(%r13), %r15
testq %r15, %r15
je 0x2c9db3
cmpl $0x0, (%r15)
jle 0x2c9db3
leaq 0x8(%r15), %r14
xorl %r12d, %r12d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2c9de8
incl %r12d
addq $0x18, %r14
cmpl (%r15), %r12d
jl 0x2c9d98
incl %ebp
addq $0x70, %r13
movq 0x10(%rsp), %r14
cmpl (%r14), %ebp
jl 0x2c9d08
xorl %r12d, %r12d
jmp 0x2c9dee
movq (%rbx), %rdi
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
leaq 0x10e602(%rip), %rsi    # 0x3d83e0
movq %r12, %r8
xorl %eax, %eax
callq 0x27b48d
movl $0x1, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FixSelect
SQLITE_PRIVATE int sqlite3FixSelect(
  DbFixer *pFix,       /* Context of the fixation */
  Select *pSelect      /* The SELECT statement to be fixed to one database */
){
  while( pSelect ){
    if( sqlite3FixExprList(pFix, pSelect->pEList) ){
      return 1;
    }
    if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
      return 1;
    }
    if( pSelect->pWith ){
      int i;
      for(i=0; i<pSelect->pWith->nCte; i++){
        if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){
          return 1;
        }
      }
    }
    pSelect = pSelect->pPrior;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2ca49f
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0x2ca39b
cmpl $0x0, (%r15)
jle 0x2ca39b
leaq 0x8(%r15), %r12
xorl %ebp, %ebp
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2ca4a3
incl %ebp
addq $0x18, %r12
cmpl (%r15), %ebp
jl 0x2ca37c
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x2c9cb8
movl $0x1, %ebp
testl %eax, %eax
jne 0x2ca4a8
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2ca4a8
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x2ca3fe
cmpl $0x0, (%r15)
jle 0x2ca3fe
leaq 0x8(%r15), %r12
xorl %r13d, %r13d
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2ca4a8
incl %r13d
addq $0x18, %r12
cmpl (%r15), %r13d
jl 0x2ca3de
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2ca4a8
movq 0x48(%rbx), %r15
testq %r15, %r15
je 0x2ca444
cmpl $0x0, (%r15)
jle 0x2ca444
leaq 0x8(%r15), %r12
xorl %r13d, %r13d
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2ca4a8
incl %r13d
addq $0x18, %r12
cmpl (%r15), %r13d
jl 0x2ca428
movq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x2ca4b9
testl %eax, %eax
jne 0x2ca4a8
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x2ca48e
cmpl $0x0, (%rax)
jle 0x2ca48e
movl $0x20, %r15d
xorl %r12d, %r12d
movq (%rax,%r15), %rsi
movq %r14, %rdi
callq 0x2ca34d
testl %eax, %eax
jne 0x2ca4a8
incq %r12
movq 0x68(%rbx), %rax
movslq (%rax), %rcx
addq $0x20, %r15
cmpq %rcx, %r12
jl 0x2ca46b
movq 0x50(%rbx), %rbx
xorl %ebp, %ebp
testq %rbx, %rbx
jne 0x2ca367
jmp 0x2ca4a8
xorl %ebp, %ebp
jmp 0x2ca4a8
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3UniqueConstraint
SQLITE_PRIVATE void sqlite3UniqueConstraint(
  Parse *pParse,    /* Parsing context */
  int onError,      /* Constraint type */
  Index *pIdx       /* The index that triggers the constraint */
){
  char *zErr;
  int j;
  StrAccum errMsg;
  Table *pTab = pIdx->pTable;

  sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
                      pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
  if( pIdx->aColExpr ){
    sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
  }else{
    for(j=0; j<pIdx->nKeyCol; j++){
      char *zCol;
      assert( pIdx->aiColumn[j]>=0 );
      zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
      if( j ) sqlite3_str_append(&errMsg, ", ", 2);
      sqlite3_str_appendall(&errMsg, pTab->zName);
      sqlite3_str_append(&errMsg, ".", 1);
      sqlite3_str_appendall(&errMsg, zCol);
    }
  }
  zErr = sqlite3StrAccumFinish(&errMsg);
  sqlite3HaltConstraint(pParse,
    IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
                            : SQLITE_CONSTRAINT_UNIQUE,
    onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movl %esi, 0x2c(%rsp)
movq 0x18(%rdx), %rbp
movq %rdi, 0x30(%rsp)
movq (%rdi), %rax
movl 0x7c(%rax), %ecx
movq $0x0, 0x10(%rsp)
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, 0x18(%rsp)
movl %ecx, 0x1c(%rsp)
movl %eax, 0x20(%rsp)
movw $0x0, 0x24(%rsp)
cmpq $0x0, 0x50(%rdx)
je 0x2ca878
movq (%r15), %rdx
leaq 0x10dbbf(%rip), %rsi    # 0x3d8426
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x274dfa
jmp 0x2ca933
cmpw $0x0, 0x5e(%r15)
je 0x2ca933
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
leaq 0xf9913(%rip), %r13     # 0x3c41a6
movq 0x8(%rbp), %rax
movq 0x8(%r15), %rcx
movswq (%rcx,%r14,2), %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rbx
testq %r14, %r14
je 0x2ca8df
movl 0x20(%rsp), %eax
leal 0x2(%rax), %ecx
cmpl 0x18(%rsp), %ecx
jae 0x2ca8cb
movl %ecx, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movw $0x202c, (%rcx,%rax)    # imm = 0x202C
jmp 0x2ca8df
movq %r12, %rdi
leaq 0xdad2c(%rip), %rsi     # 0x3a5601
movl $0x2, %edx
callq 0x274968
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x2747f8
movl 0x20(%rsp), %eax
leal 0x1(%rax), %ecx
cmpl 0x18(%rsp), %ecx
jae 0x2ca907
movl %ecx, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movb $0x2e, (%rcx,%rax)
jmp 0x2ca917
movq %r12, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x274968
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2747f8
incq %r14
movzwl 0x5e(%r15), %eax
cmpq %rax, %r14
jb 0x2ca893
leaq 0x8(%rsp), %rdi
callq 0x2749f9
movzwl 0x63(%r15), %ecx
andl $0x3, %ecx
xorl %esi, %esi
cmpw $0x2, %cx
setne %sil
shll $0x9, %esi
addl $0x613, %esi            # imm = 0x613
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movq %rax, %rcx
movl $0xfffffff9, %r8d       # imm = 0xFFFFFFF9
movl $0x2, %r9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c0013
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprIfFalseDup
SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
  sqlite3 *db = pParse->db;
  Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
  if( db->mallocFailed==0 ){
    sqlite3ExprIfFalse(pParse, pCopy, dest, jumpIfNull);
  }
  sqlite3ExprDelete(db, pCopy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %r14
movq (%rdi), %rbx
testq %rsi, %rsi
je 0x2ca9a8
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
movq %rax, %r15
jmp 0x2ca9ab
xorl %r15d, %r15d
cmpb $0x0, 0x61(%rbx)
jne 0x2ca9c3
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl $0x10, %ecx
callq 0x2bfceb
testq %r15, %r15
je 0x2ca9dd
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a6164
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IndexAffinityStr
SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
  if( !pIdx->zColAff ){
    /* The first time a column affinity string for a particular index is
    ** required, it is allocated and populated here. It is then stored as
    ** a member of the Index structure for subsequent use.
    **
    ** The column affinity string will eventually be deleted by
    ** sqliteDeleteIndex() when the Index structure itself is cleaned
    ** up.
    */
    int n;
    Table *pTab = pIdx->pTable;
    pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
    if( !pIdx->zColAff ){
      sqlite3OomFault(db);
      return 0;
    }
    for(n=0; n<pIdx->nColumn; n++){
      i16 x = pIdx->aiColumn[n];
      char aff;
      if( x>=0 ){
        aff = pTab->aCol[x].affinity;
      }else if( x==XN_ROWID ){
        aff = SQLITE_AFF_INTEGER;
      }else{
        assert( x==XN_EXPR );
        assert( pIdx->aColExpr!=0 );
        aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
      }
      if( aff<SQLITE_AFF_BLOB ) aff = SQLITE_AFF_BLOB;
      if( aff>SQLITE_AFF_NUMERIC) aff = SQLITE_AFF_NUMERIC;
      pIdx->zColAff[n] = aff;
    }
    pIdx->zColAff[n] = 0;
  }

  return pIdx->zColAff;
}

// Assembly:
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x2ca9f2
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
movzwl 0x60(%rsi), %edi
incq %rdi
callq 0x272ae6
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x2caa91
cmpw $0x0, 0x60(%rbx)
je 0x2caa9d
movl $0x4, %r12d
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movswq (%rax,%r14,2), %rax
testq %rax, %rax
js 0x2caa45
movq 0x8(%r15), %rcx
shlq $0x5, %rax
movb 0x19(%rcx,%rax), %al
jmp 0x2caa5c
cmpw $-0x1, %ax
je 0x2caa5a
movq 0x50(%rbx), %rax
movq (%rax,%r12,2), %rdi
callq 0x2c08a4
jmp 0x2caa5c
movb $0x44, %al
cmpb $0x42, %al
jge 0x2caa67
movl $0x41, %eax
jmp 0x2caa6a
movzbl %al, %eax
cmpb $0x43, %al
jl 0x2caa73
movl $0x43, %eax
movq 0x20(%rbx), %rcx
movb %al, (%rcx,%r14)
incq %r14
movzwl 0x60(%rbx), %eax
addq $0xc, %r12
cmpq %rax, %r14
jb 0x2caa29
movq 0x20(%rbx), %rax
jmp 0x2caaa0
movq %r14, %rdi
callq 0x278b1c
xorl %eax, %eax
jmp 0x2caaa9
xorl %r14d, %r14d
movb $0x0, (%rax,%r14)
movq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DropTriggerPtr
SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
  Table   *pTable;
  Vdbe *v;
  sqlite3 *db = pParse->db;
  int iDb;

  iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
  assert( iDb>=0 && iDb<db->nDb );
  pTable = tableOfTrigger(pTrigger);
  assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( pTable ){
    int code = SQLITE_DROP_TRIGGER;
    const char *zDb = db->aDb[iDb].zDbSName;
    const char *zTab = SCHEMA_TABLE(iDb);
    if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
    if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
      sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
      return;
    }
  }
#endif

  /* Generate code to destroy the database record of the trigger.
  */
  if( (v = sqlite3GetVdbe(pParse))!=0 ){
    sqlite3NestedParse(pParse,
       "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'",
       db->aDb[iDb].zDbSName, pTrigger->zName
    );
    sqlite3ChangeCookie(pParse, iDb);
    sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x2cb05f
movq 0x20(%r12), %rcx
addq $0x18, %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
leaq 0x20(%rcx), %rdx
cmpq %rax, (%rcx)
movq %rdx, %rcx
jne 0x2cb04f
jmp 0x2cb064
movl $0xffff8000, %ebp       # imm = 0xFFFF8000
movq 0x8(%rbx), %rsi
movq 0x30(%rbx), %rdi
addq $0x8, %rdi
xorl %edx, %edx
callq 0x2a547e
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2cb0ea
movq 0x20(%r12), %rcx
movslq %ebp, %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq (%rcx,%rsi), %r15
xorl %ecx, %ecx
cmpl $0x1, %edx
setne %cl
leal 0xe(,%rcx,2), %esi
movq (%rbx), %rdx
movq (%rax), %rcx
movq %r14, %rdi
movq %r15, %r8
callq 0x2c37ba
testl %eax, %eax
jne 0x2cb173
cmpl $0x1, %ebp
leaq 0x10b54f(%rip), %rax    # 0x3d6614
leaq 0x10b467(%rip), %rdx    # 0x3d6533
cmoveq %rax, %rdx
movq %r14, %rdi
movl $0x9, %esi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x2c37ba
testl %eax, %eax
jne 0x2cb173
movq %r14, %rdi
callq 0x2bc630
testq %rax, %rax
je 0x2cb173
movq %rax, %r15
movq 0x20(%r12), %rax
movslq %ebp, %r12
shlq $0x5, %r12
movq (%rax,%r12), %rdx
movq (%rbx), %rcx
leaq 0x10d534(%rip), %rsi    # 0x3d8648
movq %r14, %rdi
xorl %eax, %eax
callq 0x2c461b
movq (%r14), %rax
movq 0x10(%r14), %rdi
movq 0x20(%rax), %rax
movq 0x18(%rax,%r12), %rax
movl (%rax), %r8d
incl %r8d
movl $0x5e, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x2a83e1
movq (%rbx), %rbx
movq %r15, %rdi
movl $0x91, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r15, %rdi
movl %eax, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27b778
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: destroyRootPage
static void destroyRootPage(Parse *pParse, int iTable, int iDb){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int r1 = sqlite3GetTempReg(pParse);
  if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
  sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
  sqlite3MayAbort(pParse);
#ifndef SQLITE_OMIT_AUTOVACUUM
  /* OP_Destroy stores an in integer r1. If this integer
  ** is non-zero, then it is the root page number of a table moved to
  ** location iTable. The following code modifies the sqlite_schema table to
  ** reflect this.
  **
  ** The "#NNN" in the SQL is a special constant that means whatever value
  ** is in register NNN.  See grammar rules associated with the TK_REGISTER
  ** token for additional information.
  */
  sqlite3NestedParse(pParse,
     "UPDATE %Q." DFLT_SCHEMA_TABLE
     " SET rootpage=%d WHERE #%d AND rootpage=#%d",
     pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
#endif
  sqlite3ReleaseTempReg(pParse, r1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x2bc630
movq %rax, %r12
movb 0x1f(%rbx), %al
testb %al, %al
je 0x2cb1ad
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xd4(%rbx,%rax,4), %ebp
jmp 0x2cb1b5
movl 0x38(%rbx), %ebp
incl %ebp
movl %ebp, 0x38(%rbx)
cmpl $0x1, %r14d
jg 0x2cb1cc
leaq 0x10d4c4(%rip), %rsi    # 0x3d8686
movq %rbx, %rdi
xorl %eax, %eax
callq 0x27b48d
movq %r12, %rdi
movl $0x88, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x2a83e1
movq 0xa0(%rbx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
movb $0x1, 0x21(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rax
movslq %r15d, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rdx
leaq 0x10d489(%rip), %rsi    # 0x3d8695
movq %rbx, %rdi
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x2c461b
testl %ebp, %ebp
je 0x2cb23a
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x2cb23a
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xd4(%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unsetJoinExpr
static void unsetJoinExpr(Expr *p, int iTable){
  while( p ){
    if( ExprHasProperty(p, EP_FromJoin)
     && (iTable<0 || p->iRightJoinTable==iTable) ){
      ExprClearProperty(p, EP_FromJoin);
    }
    if( p->op==TK_FUNCTION && p->x.pList ){
      int i;
      for(i=0; i<p->x.pList->nExpr; i++){
        unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
      }
    }
    unsetJoinExpr(p->pLeft, iTable);
    p = p->pRight;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2cba4e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%r14), %eax
testb $0x1, %al
je 0x2cb9f4
testl %ebx, %ebx
js 0x2cb9ed
movswl 0x34(%r14), %ecx
cmpl %ebx, %ecx
jne 0x2cb9f4
andl $-0x2, %eax
movl %eax, 0x4(%r14)
cmpb $-0x57, (%r14)
jne 0x2cba2f
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x2cba2f
cmpl $0x0, (%rax)
jle 0x2cba2f
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%rax,%r15), %rdi
movl %ebx, %esi
callq 0x2cb9c2
incq %r12
movq 0x20(%r14), %rax
movslq (%rax), %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0x2cba11
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x2cb9c2
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x2cb9d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeExplainPop
SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse *pParse){
  VdbeOp *pOp;
  if( pParse->addrExplain==0 ) return 0;
  pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
  return pOp->p2;
}

// Assembly:
movl 0x128(%rdi), %ecx
testl %ecx, %ecx
je 0x2cdb01
movq 0x10(%rdi), %rax
jns 0x2cdaef
movl 0x90(%rax), %ecx
decl %ecx
movq (%rax), %rdx
cmpb $0x0, 0x61(%rdx)
je 0x2cdb05
leaq 0x1f1389(%rip), %rcx    # 0x4bee88
jmp 0x2cdb17
xorl %eax, %eax
jmp 0x2cdb1a
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rax), %rcx
movl 0x8(%rcx), %eax
movl %eax, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: propagateConstants
static int propagateConstants(
  Parse *pParse,   /* The parsing context */
  Select *p        /* The query in which to propagate constants */
){
  WhereConst x;
  Walker w;
  int nChng = 0;
  x.pParse = pParse;
  do{
    x.nConst = 0;
    x.nChng = 0;
    x.apExpr = 0;
    findConstInWhere(&x, p->pWhere);
    if( x.nConst ){
      memset(&w, 0, sizeof(w));
      w.pParse = pParse;
      w.xExprCallback = propagateConstantExprRewrite;
      w.xSelectCallback = sqlite3SelectWalkNoop;
      w.xSelectCallback2 = 0;
      w.walkerDepth = 0;
      w.u.pConst = &x;
      sqlite3WalkExpr(&w, p->pWhere);
      sqlite3DbFree(x.pParse->db, x.apExpr);
      nChng += x.nChng;
    }
  }while( x.nChng );
  return nChng;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r13
movq %rdi, -0x8(%r13)
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
leaq -0x4682(%rip), %r12     # 0x2c94cb
movups %xmm0, (%r13)
movq 0x30(%rbx), %rsi
movq %r15, %rdi
callq 0x2d37c2
cmpl $0x0, 0x8(%rsp)
je 0x2cdbbf
movq %r14, 0x18(%rsp)
leaq 0x5d64(%rip), %rax      # 0x2d38d5
movq %rax, 0x20(%rsp)
movq %r12, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movq %r15, 0x40(%rsp)
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x2cdb9e
leaq 0x18(%rsp), %rdi
callq 0x2c0a8c
xorps %xmm0, %xmm0
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x2cdbb7
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x282904
xorps %xmm0, %xmm0
movl 0xc(%rsp), %eax
addl %eax, %ebp
jmp 0x2cdbc6
movl 0xc(%rsp), %eax
xorps %xmm0, %xmm0
testl %eax, %eax
jne 0x2cdb4d
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: isSelfJoinView
static struct SrcList_item *isSelfJoinView(
  SrcList *pTabList,           /* Search for self-joins in this FROM clause */
  struct SrcList_item *pThis   /* Search for prior reference to this subquery */
){
  struct SrcList_item *pItem;
  for(pItem = pTabList->a; pItem<pThis; pItem++){
    Select *pS1;
    if( pItem->pSelect==0 ) continue;
    if( pItem->fg.viaCoroutine ) continue;
    if( pItem->zName==0 ) continue;
    assert( pItem->pTab!=0 );
    assert( pThis->pTab!=0 );
    if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
    if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
    pS1 = pItem->pSelect;
    if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
      /* The query flattener left two different CTE tables with identical
      ** names in the same FROM clause. */
      continue;
    }
    if( sqlite3ExprCompare(0, pThis->pSelect->pWhere, pS1->pWhere, -1)
     || sqlite3ExprCompare(0, pThis->pSelect->pHaving, pS1->pHaving, -1)
    ){
      /* The view was modified by some other optimization such as
      ** pushDownWhereTerms() */
      continue;
    }
    return pItem;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rbx
cmpq %rsi, %rbx
jae 0x2cde08
movq %rsi, %r14
leaq 0x10358b(%rip), %r15    # 0x3d12e0
movq 0x28(%rbx), %r12
testq %r12, %r12
je 0x2cdd7f
testb $0x10, 0x3d(%rbx)
jne 0x2cdd7f
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x2cdd7f
movq 0x20(%rbx), %rcx
movq 0x70(%rcx), %rcx
movq 0x20(%r14), %rdx
cmpq 0x70(%rdx), %rcx
je 0x2cdd8a
addq $0x70, %rbx
cmpq %r14, %rbx
jb 0x2cdd55
jmp 0x2cde08
movq 0x10(%r14), %rdx
testq %rdx, %rdx
je 0x2cdd7f
xorl %esi, %esi
movzbl (%rax,%rsi), %edi
movzbl (%rdx,%rsi), %r8d
cmpb %r8b, %dil
jne 0x2cddaa
testq %rdi, %rdi
jne 0x2cddb4
jmp 0x2cddb9
movb (%rdi,%r15), %dil
cmpb (%r8,%r15), %dil
jne 0x2cdd7f
incq %rsi
jmp 0x2cdd95
movq 0x28(%r14), %rax
testq %rcx, %rcx
jne 0x2cddcc
movl 0x10(%rax), %ecx
cmpl 0x10(%r12), %ecx
jne 0x2cdd7f
movq 0x30(%rax), %rsi
movq 0x30(%r12), %rdx
xorl %edi, %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2c0d98
testl %eax, %eax
jne 0x2cdd7f
movq 0x28(%r14), %rax
movq 0x40(%rax), %rsi
movq 0x40(%r12), %rdx
xorl %edi, %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2c0d98
testl %eax, %eax
jne 0x2cdd7f
jmp 0x2cde0a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3KeyInfoFromExprList
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(
  Parse *pParse,       /* Parsing context */
  ExprList *pList,     /* Form the KeyInfo object from this ExprList */
  int iStart,          /* Begin with this column of pList */
  int nExtra           /* Add this many extra columns to the end */
){
  int nExpr;
  KeyInfo *pInfo;
  struct ExprList_item *pItem;
  sqlite3 *db = pParse->db;
  int i;

  nExpr = pList->nExpr;
  pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
  if( pInfo ){
    assert( sqlite3KeyInfoIsWriteable(pInfo) );
    for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){
      pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
      pInfo->aSortFlags[i-iStart] = pItem->sortFlags;
    }
  }
  return pInfo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
movl (%rsi), %r14d
leal 0x1(%rcx), %edx
subl %ebp, %r14d
setle %r13b
movl %r14d, %esi
callq 0x2bcb86
movq %rax, %r15
testq %rax, %rax
sete %al
orb %r13b, %al
jne 0x2cde99
movl %ebp, %eax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,8), %r12
addq $0x8, %r12
xorl %r13d, %r13d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x2a9678
testq %rax, %rax
jne 0x2cde7b
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%r15,%r13,8)
movb 0x10(%r12), %al
movq 0x18(%r15), %rcx
movb %al, (%rcx,%r13)
addq $0x18, %r12
incq %r13
cmpl %r13d, %r14d
jne 0x2cde63
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAnalyzeAggregates
SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
  Walker w;
  w.xExprCallback = analyzeAggregate;
  w.xSelectCallback = sqlite3WalkerDepthIncrease;
  w.xSelectCallback2 = sqlite3WalkerDepthDecrease;
  w.walkerDepth = 0;
  w.u.pNC = pNC;
  w.pParse = 0;
  assert( pNC->pSrcList!=0 );
  sqlite3WalkExpr(&w, pExpr);
}

// Assembly:
subq $0x38, %rsp
leaq 0xeaec(%rip), %rax      # 0x2e051e
movq %rax, 0x10(%rsp)
leaq 0xe5b(%rip), %rax       # 0x2d2899
movq %rax, 0x18(%rsp)
leaq 0xe55(%rip), %rax       # 0x2d289f
movq %rax, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq $0x0, 0x8(%rsp)
testq %rsi, %rsi
je 0x2d1a74
leaq 0x8(%rsp), %rdi
callq 0x2c0a8c
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: minMaxQuery
static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
  int eRet = WHERE_ORDERBY_NORMAL;      /* Return value */
  ExprList *pEList = pFunc->x.pList;    /* Arguments to agg function */
  const char *zFunc;                    /* Name of aggregate function pFunc */
  ExprList *pOrderBy;
  u8 sortFlags = 0;

  assert( *ppMinMax==0 );
  assert( pFunc->op==TK_AGG_FUNCTION );
  assert( !IsWindowFunc(pFunc) );
  if( pEList==0 || pEList->nExpr!=1 || ExprHasProperty(pFunc, EP_WinFunc) ){
    return eRet;
  }
  zFunc = pFunc->u.zToken;
  if( sqlite3StrICmp(zFunc, "min")==0 ){
    eRet = WHERE_ORDERBY_MIN;
    if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
      sortFlags = KEYINFO_ORDER_BIGNULL;
    }
  }else if( sqlite3StrICmp(zFunc, "max")==0 ){
    eRet = WHERE_ORDERBY_MAX;
    sortFlags = KEYINFO_ORDER_DESC;
  }else{
    return eRet;
  }
  *ppMinMax = pOrderBy = sqlite3ExprListDup(db, pEList, 0);
  assert( pOrderBy!=0 || db->mallocFailed );
  if( pOrderBy ) pOrderBy->a[0].sortFlags = sortFlags;
  return eRet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rsi), %r14
testq %r14, %r14
je 0x2d1b24
cmpl $0x1, (%r14)
jne 0x2d1b24
testb $0x1, 0x7(%rsi)
jne 0x2d1b24
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rax
xorl %edx, %edx
leaq 0xbc78d(%rip), %rsi     # 0x38e242
leaq 0xff824(%rip), %rcx     # 0x3d12e0
movzbl (%rax,%rdx), %edi
movzbl (%rdx,%rsi), %r8d
cmpb %r8b, %dil
jne 0x2d1ad1
testq %rdi, %rdi
jne 0x2d1adb
jmp 0x2d1ae0
movb (%rdi,%rcx), %dil
cmpb (%r8,%rcx), %dil
jne 0x2d1af7
incq %rdx
jmp 0x2d1abc
movq 0x8(%r14), %rdi
callq 0x2c262e
testl %eax, %eax
setne %r12b
addb %r12b, %r12b
movb $0x1, %bpl
jmp 0x2d1b37
xorl %edx, %edx
leaq 0xf03ab(%rip), %rsi     # 0x3c1eab
movzbl (%rax,%rdx), %edi
movzbl (%rdx,%rsi), %r8d
cmpb %r8b, %dil
jne 0x2d1b15
testq %rdi, %rdi
jne 0x2d1b1f
jmp 0x2d1b31
movb (%rdi,%rcx), %dil
cmpb (%r8,%rcx), %dil
jne 0x2d1b24
incq %rdx
jmp 0x2d1b00
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
movb $0x2, %bpl
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2c2deb
movq %rax, (%rbx)
testq %rax, %rax
je 0x2d1b26
movb %r12b, 0x18(%rax)
jmp 0x2d1b26
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: finalizeAggFunctions
static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
  Vdbe *v = pParse->pVdbe;
  int i;
  struct AggInfo_func *pF;
  for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
    ExprList *pList = pF->pFExpr->x.pList;
    assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) );
    sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0);
    sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
  }
}

// Assembly:
cmpl $0x0, 0x38(%rsi)
jle 0x2d1f65
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %r15
xorl %ebp, %ebp
movq (%r15), %rax
movq 0x20(%rax), %rax
movl $0x0, %ecx
testq %rax, %rax
je 0x2d1f06
movl (%rax), %ecx
movl 0x10(%r15), %edx
movq %r14, %rdi
movl $0x9d, %esi
xorl %r8d, %r8d
callq 0x2a83e1
movq 0x8(%r15), %rsi
movq (%r14), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2d1f34
testb $0x10, 0x4(%rsi)
je 0x2d1f50
callq 0x282904
jmp 0x2d1f50
movq 0x88(%r14), %rax
movslq 0x90(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
movb $-0x8, -0x17(%rax,%rcx,8)
movq %rsi, -0x8(%rax,%rcx,8)
incl %ebp
addq $0x18, %r15
cmpl 0x38(%rbx), %ebp
jl 0x2d1ef3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resetAccumulator
static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
  Vdbe *v = pParse->pVdbe;
  int i;
  struct AggInfo_func *pFunc;
  int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
  if( nReg==0 ) return;
  if( pParse->nErr || pParse->db->mallocFailed ) return;
#ifdef SQLITE_DEBUG
  /* Verify that all AggInfo registers are within the range specified by
  ** AggInfo.mnReg..AggInfo.mxReg */
  assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
  for(i=0; i<pAggInfo->nColumn; i++){
    assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
         && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
  }
  for(i=0; i<pAggInfo->nFunc; i++){
    assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
         && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
  }
#endif
  sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
  for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
    if( pFunc->iDistinct>=0 ){
      Expr *pE = pFunc->pFExpr;
      assert( !ExprHasProperty(pE, EP_xIsSelect) );
      if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
        sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
           "argument");
        pFunc->iDistinct = -1;
      }else{
        KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
        sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
                          (char*)pKeyInfo, P4_KEYINFO);
      }
    }
  }
}

// Assembly:
movl 0x38(%rsi), %eax
addl 0x28(%rsi), %eax
je 0x2d205b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x0, 0x30(%rdi)
jne 0x2d204d
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2d204d
movq %rsi, %rbx
movq 0x10(%r14), %rdi
movl 0x10(%rsi), %ecx
movl 0x14(%rsi), %r8d
movq %rdi, (%rsp)
movl $0x48, %esi
xorl %edx, %edx
callq 0x2a83e1
cmpl $0x0, 0x38(%rbx)
jle 0x2d204d
movq 0x30(%rbx), %rbp
addq $0x14, %rbp
leaq 0x106c0b(%rip), %r15    # 0x3d8bd9
xorl %r12d, %r12d
cmpl $0x0, (%rbp)
js 0x2d2040
movq -0x14(%rbp), %rax
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x2d202c
cmpl $0x1, (%rsi)
jne 0x2d202c
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cde19
movq %rax, %r13
movl (%rbp), %edx
movq (%rsp), %r15
movq %r15, %rdi
movl $0x64, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r15, %rdi
movl %eax, %esi
movq %r13, %rdx
leaq 0x106bb9(%rip), %r15    # 0x3d8bd9
movl $0xfffffff7, %ecx       # imm = 0xFFFFFFF7
callq 0x27b778
jmp 0x2d2040
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x27b48d
movl $0xffffffff, (%rbp)     # imm = 0xFFFFFFFF
incl %r12d
addq $0x18, %rbp
cmpl 0x38(%rbx), %r12d
jl 0x2d1fd1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: explainSimpleCount
static void explainSimpleCount(
  Parse *pParse,                  /* Parse context */
  Table *pTab,                    /* Table being queried */
  Index *pIdx                     /* Index used to optimize scan, or NULL */
){
  if( pParse->explain==2 ){
    int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
    sqlite3VdbeExplain(pParse, 0, "SCAN TABLE %s%s%s",
        pTab->zName,
        bCover ? " USING COVERING INDEX " : "",
        bCover ? pIdx->zName : ""
    );
  }
}

// Assembly:
cmpb $0x2, 0x11b(%rdi)
jne 0x2d20cd
testq %rdx, %rdx
je 0x2d20ce
testb $-0x80, 0x40(%rsi)
jne 0x2d20d3
movq (%rsi), %rcx
jmp 0x2d20ef
retq
movq (%rsi), %rcx
jmp 0x2d20e3
movzwl 0x63(%rdx), %eax
andl $0x3, %eax
movq (%rsi), %rcx
cmpw $0x2, %ax
jne 0x2d20ef
leaq 0xf8086(%rip), %r8      # 0x3ca170
movq %r8, %r9
jmp 0x2d20f9
movq (%rdx), %r9
leaq 0x106b25(%rip), %r8     # 0x3d8c1e
leaq 0x106b0c(%rip), %rdx    # 0x3d8c0c
xorl %esi, %esi
xorl %eax, %eax
jmp 0x2c1741