LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3NestedParse
SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
  va_list ap;
  char *zSql;
  char *zErrMsg = 0;
  sqlite3 *db = pParse->db;
  char saveBuf[PARSE_TAIL_SZ];

  if( pParse->nErr ) return;
  assert( pParse->nested<10 );  /* Nesting should only be of limited depth */
  va_start(ap, zFormat);
  zSql = sqlite3VMPrintf(db, zFormat, ap);
  va_end(ap);
  if( zSql==0 ){
    /* This can result either from an OOM or because the formatted string
    ** exceeds SQLITE_LIMIT_LENGTH.  In the latter case, we need to set
    ** an error */
    if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
    pParse->nErr++;
    return;
  }
  pParse->nested++;
  memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
  memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
  sqlite3RunParser(pParse, zSql, &zErrMsg);
  sqlite3DbFree(db, zErrMsg);
  sqlite3DbFree(db, zSql);
  memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
  pParse->nested--;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x26acf3
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
andq $0x0, 0x8(%rsp)
cmpl $0x0, 0x30(%rdi)
jne 0x26adc1
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x1c0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %r14, %rdi
callq 0x22efaa
testq %rax, %rax
je 0x26adb0
movq %rax, %r15
incb 0x1e(%rbx)
leaq 0x108(%rbx), %r12
leaq 0xe0(%rsp), %r13
movl $0xa0, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x17630
movl $0xa0, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x17380
leaq 0x8(%rsp), %rbp
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x228e55
movq (%rbp), %rsi
movq %r14, %rdi
callq 0x21f26b
movq %r14, %rdi
movq %r15, %rsi
callq 0x22d0fc
movl $0xa0, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x17630
decb 0x1e(%rbx)
jmp 0x26adc1
cmpb $0x0, 0x61(%r14)
jne 0x26adbe
movl $0x12, 0x18(%rbx)
incl 0x30(%rbx)
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ChangeCookie
SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
  sqlite3 *db = pParse->db;
  Vdbe *v = pParse->pVdbe;
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
                   (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
}

// Assembly:
movq (%rdi), %rax
movq 0x10(%rdi), %rdi
movq 0x20(%rax), %rax
movslq %esi, %rdx
movq %rdx, %rcx
shlq $0x5, %rcx
movq 0x18(%rax,%rcx), %rax
movl (%rax), %r8d
incl %r8d
pushq $0x5e
popq %rsi
pushq $0x1
popq %rcx
jmp 0x24d51f
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RenameTokenRemap
SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, void *pTo, void *pFrom){
  RenameToken *p;
  renameTokenCheckAll(pParse, pTo);
  for(p=pParse->pRename; p; p=p->pNext){
    if( p->p==pFrom ){
      p->p = pTo;
      break;
    }
  }
}

// Assembly:
addq $0x1a0, %rdi            # imm = 0x1A0
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x26ae5b
cmpq %rdx, (%rdi)
je 0x26ae58
addq $0x18, %rdi
jmp 0x26ae45
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: isDupColumn
static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
  int i, j;
  assert( nKey<=pIdx->nColumn );
  assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
  assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
  assert( pPk->pTable->tabFlags & TF_WithoutRowid );
  assert( pPk->pTable==pIdx->pTable );
  testcase( pPk==pIdx );
  j = pPk->aiColumn[iCol];
  assert( j!=XN_ROWID && j!=XN_EXPR );
  for(i=0; i<nKey; i++){
    assert( pIdx->aiColumn[i]>=0 || j>=0 );
    if( pIdx->aiColumn[i]==j
     && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movq 0x8(%rdx), %rax
movslq %ecx, %r13
movzwl (%rax,%r13,2), %ebp
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r15d
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0x26aeb5
movq 0x8(%r12), %rax
cmpw %bp, (%rax,%rbx,2)
jne 0x26aeb0
movq 0x40(%r12), %rax
movq (%rax,%rbx,8), %rdi
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rsi
callq 0x221779
testl %eax, %eax
je 0x26aeb9
incq %rbx
jmp 0x26ae86
xorl %eax, %eax
jmp 0x26aebc
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: recomputeColumnsNotIndexed
static void recomputeColumnsNotIndexed(Index *pIdx){
  Bitmask m = 0;
  int j;
  Table *pTab = pIdx->pTable;
  for(j=pIdx->nColumn-1; j>=0; j--){
    int x = pIdx->aiColumn[j];
    if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
      testcase( x==BMS-1 );
      testcase( x==BMS-2 );
      if( x<BMS-1 ) m |= MASKBIT(x);
    }
  }
  pIdx->colNotIdxed = ~m;
  assert( (pIdx->colNotIdxed>>63)==1 );
}

// Assembly:
movq 0x18(%rdi), %rcx
movzwl 0x60(%rdi), %edx
xorl %eax, %eax
testq %rdx, %rdx
jle 0x26afbc
movq 0x8(%rdi), %rsi
movswq -0x2(%rsi,%rdx,2), %rsi
testq %rsi, %rsi
js 0x26afb1
cmpw $0x3e, %si
ja 0x26afb1
movq 0x8(%rcx), %r8
movq %rsi, %r9
shlq $0x5, %r9
movzwl 0x1c(%r8,%r9), %r8d
andl $0x20, %r8d
je 0x26afb6
decq %rdx
jmp 0x26af80
btsq %rsi, %rax
jmp 0x26afb1
notq %rax
movq %rax, 0x68(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResolveExprNames
SQLITE_PRIVATE int sqlite3ResolveExprNames(
  NameContext *pNC,       /* Namespace to resolve expressions in. */
  Expr *pExpr             /* The expression to be analyzed. */
){
  int savedHasAgg;
  Walker w;

  if( pExpr==0 ) return SQLITE_OK;
  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  w.pParse = pNC->pParse;
  w.xExprCallback = resolveExprStep;
  w.xSelectCallback = resolveSelectStep;
  w.xSelectCallback2 = 0;
  w.u.pNC = pNC;
#if SQLITE_MAX_EXPR_DEPTH>0
  w.pParse->nHeight += pExpr->nHeight;
  if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
    return SQLITE_ERROR;
  }
#endif
  sqlite3WalkExpr(&w, pExpr);
#if SQLITE_MAX_EXPR_DEPTH>0
  w.pParse->nHeight -= pExpr->nHeight;
#endif
  assert( EP_Agg==NC_HasAgg );
  assert( EP_Win==NC_HasWin );
  testcase( pNC->ncFlags & NC_HasAgg );
  testcase( pNC->ncFlags & NC_HasWin );
  ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
  pNC->ncFlags |= savedHasAgg;
  return pNC->nErr>0 || w.pParse->nErr>0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %rsi, %rsi
je 0x26b07e
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rdi), %r12d
movl %r12d, %eax
andl $0xffff6fef, %eax       # imm = 0xFFFF6FEF
movl %eax, 0x28(%rdi)
movq (%rdi), %rdi
movq %rdi, (%rsp)
leaq 0x19e(%rip), %rax       # 0x26b19a
movq %rax, 0x8(%rsp)
leaq 0x174d(%rip), %rax      # 0x26c755
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movq %rbx, 0x28(%rsp)
movl 0x124(%rdi), %esi
addl 0x28(%r14), %esi
movl %esi, 0x124(%rdi)
callq 0x26cf29
pushq $0x1
popq %rbp
testl %eax, %eax
jne 0x26b080
andl $0x9010, %r12d          # imm = 0x9010
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x267f8f
movl 0x28(%r14), %ecx
movq (%r15), %rax
subl %ecx, 0x124(%rax)
movl 0x28(%rbx), %ecx
movl %ecx, %edx
andl $0x8010, %edx           # imm = 0x8010
orl %edx, 0x4(%r14)
orl %ecx, %r12d
movl %r12d, 0x28(%rbx)
cmpl $0x0, 0x24(%rbx)
jg 0x26b080
xorl %ebp, %ebp
cmpl $0x0, 0x30(%rax)
setg %bpl
jmp 0x26b080
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResolveExprListNames
SQLITE_PRIVATE int sqlite3ResolveExprListNames(
  NameContext *pNC,       /* Namespace to resolve expressions in. */
  ExprList *pList         /* The expression list to be analyzed. */
){
  int i;
  int savedHasAgg = 0;
  Walker w;
  if( pList==0 ) return WRC_Continue;
  w.pParse = pNC->pParse;
  w.xExprCallback = resolveExprStep;
  w.xSelectCallback = resolveSelectStep;
  w.xSelectCallback2 = 0;
  w.u.pNC = pNC;
  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  for(i=0; i<pList->nExpr; i++){
    Expr *pExpr = pList->a[i].pExpr;
    if( pExpr==0 ) continue;
#if SQLITE_MAX_EXPR_DEPTH>0
    w.pParse->nHeight += pExpr->nHeight;
    if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
      return WRC_Abort;
    }
#endif
    sqlite3WalkExpr(&w, pExpr);
#if SQLITE_MAX_EXPR_DEPTH>0
    w.pParse->nHeight -= pExpr->nHeight;
#endif
    assert( EP_Agg==NC_HasAgg );
    assert( EP_Win==NC_HasWin );
    testcase( pNC->ncFlags & NC_HasAgg );
    testcase( pNC->ncFlags & NC_HasWin );
    if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){
      ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
      savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
      pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
    }
    if( pNC->nErr>0 || w.pParse->nErr>0 ) return WRC_Abort;
  }
  pNC->ncFlags |= savedHasAgg;
  return WRC_Continue;
}

// Assembly:
testq %rsi, %rsi
je 0x26b180
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8(%rsp), %rcx
movq %rdi, (%rcx)
leaq 0xdc(%rip), %rax        # 0x26b19a
movq %rax, 0x8(%rcx)
leaq 0x168c(%rip), %rax      # 0x26c755
movq %rax, 0x10(%rcx)
andq $0x0, 0x18(%rcx)
movq %rbx, 0x28(%rcx)
movl 0x28(%rbx), %eax
movl %eax, %r13d
andl $0x9010, %r13d          # imm = 0x9010
andl $0xffff6fef, %eax       # imm = 0xFFFF6FEF
movl %eax, 0x28(%rbx)
leaq 0x8(%rsi), %rbp
xorl %r15d, %r15d
movslq (%r14), %rcx
cmpq %rcx, %r15
jge 0x26b183
movq (%rbp), %r12
testq %r12, %r12
je 0x26b16f
movl 0x124(%rdi), %esi
addl 0x28(%r12), %esi
movl %esi, 0x124(%rdi)
callq 0x26cf29
testl %eax, %eax
jne 0x26b17b
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x267f8f
movl 0x28(%r12), %eax
movq 0x8(%rsp), %rdi
subl %eax, 0x124(%rdi)
movl 0x28(%rbx), %eax
movl %eax, %ecx
andl $0x9010, %ecx           # imm = 0x9010
je 0x26b163
movl %eax, %edx
andl $0x8010, %edx           # imm = 0x8010
orl %edx, 0x4(%r12)
orl %ecx, %r13d
andl $0xffff6fef, %eax       # imm = 0xFFFF6FEF
movl %eax, 0x28(%rbx)
cmpl $0x0, 0x24(%rbx)
jg 0x26b17b
cmpl $0x0, 0x30(%rdi)
jg 0x26b17b
incq %r15
addq $0x18, %rbp
jmp 0x26b0f2
pushq $0x2
popq %rax
jmp 0x26b18b
xorl %eax, %eax
retq
orl %r13d, %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: notValidImpl
static void notValidImpl(
   Parse *pParse,       /* Leave error message here */
   NameContext *pNC,    /* The name context */
   const char *zMsg,    /* Type of error */
   Expr *pExpr          /* Invalidate this expression on error */
){
  const char *zIn = "partial index WHERE clauses";
  if( pNC->ncFlags & NC_IdxExpr )      zIn = "index expressions";
#ifndef SQLITE_OMIT_CHECK
  else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
#endif
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns";
#endif
  sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
  if( pExpr ) pExpr->op = TK_NULL;
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl 0x28(%rsi), %eax
testb $0x20, %al
jne 0x26cf74
testb $0x4, %al
jne 0x26cf7d
testb $0x8, %al
leaq 0x10af68(%rip), %rax    # 0x377ecf
leaq 0x10afa1(%rip), %rcx    # 0x377f0f
cmoveq %rax, %rcx
jmp 0x26cf84
leaq 0x10af70(%rip), %rcx    # 0x377eeb
jmp 0x26cf84
leaq 0x10af79(%rip), %rcx    # 0x377efd
leaq 0x10af96(%rip), %rsi    # 0x377f21
xorl %eax, %eax
callq 0x226dce
testq %rbx, %rbx
je 0x26cf9a
movb $0x77, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3MatchEName
SQLITE_PRIVATE int sqlite3MatchEName(
  const struct ExprList_item *pItem,
  const char *zCol,
  const char *zTab,
  const char *zDb
){
  int n;
  const char *zSpan;
  if( pItem->eEName!=ENAME_TAB ) return 0;
  zSpan = pItem->zEName;
  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
  if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
    return 0;
  }
  zSpan += n+1;
  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
  if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){
    return 0;
  }
  zSpan += n+1;
  if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){
    return 0;
  }
  return 1;
}

// Assembly:
movb 0x11(%rdi), %al
andb $0x3, %al
cmpb $0x2, %al
jne 0x26cfd8
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1(%rdi), %r15
xorl %r13d, %r13d
movzbl -0x1(%r15), %eax
testl %eax, %eax
je 0x26cfdb
cmpl $0x2e, %eax
je 0x26cfdb
incq %r13
incq %r15
jmp 0x26cfc2
xorl %eax, %eax
retq
testq %r12, %r12
je 0x26cffa
movq %r12, %rsi
movl %r13d, %edx
callq 0x2217ad
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x26d055
cmpb $0x0, (%r12,%r13)
jne 0x26d055
leaq 0x1(%r15), %r12
xorl %r13d, %r13d
movzbl -0x1(%r12), %eax
testl %eax, %eax
je 0x26d018
cmpl $0x2e, %eax
je 0x26d018
incq %r13
incq %r12
jmp 0x26d001
testq %r14, %r14
je 0x26d03a
movq %r15, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x2217ad
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x26d055
cmpb $0x0, (%r14,%r13)
jne 0x26d055
testq %rbx, %rbx
je 0x26d052
movq %r12, %rdi
movq %rbx, %rsi
callq 0x221779
testl %eax, %eax
je 0x26d052
xorl %eax, %eax
jmp 0x26d055
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3StrIHash
SQLITE_PRIVATE u8 sqlite3StrIHash(const char *z){
  u8 h = 0;
  if( z==0 ) return 0;
  while( z[0] ){
    h += UpperToLower[(unsigned char)z[0]];
    z++;
  }
  return h;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x26d07d
leaq 0x104683(%rip), %rcx    # 0x3716f0
movzbl (%rdi), %edx
testq %rdx, %rdx
je 0x26d07d
addb (%rdx,%rcx), %al
incq %rdi
jmp 0x26d06d
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprColUsed
SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
  int n;
  Table *pExTab;

  n = pExpr->iColumn;
  pExTab = pExpr->y.pTab;
  assert( pExTab!=0 );
  if( (pExTab->tabFlags & TF_HasGenerated)!=0
   && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0
  ){
    testcase( pExTab->nCol==BMS-1 );
    testcase( pExTab->nCol==BMS );
    return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
  }else{
    testcase( n==BMS-1 );
    testcase( n==BMS );
    if( n>=BMS ) n = BMS-1;
    return ((Bitmask)1)<<n;
  }
}

// Assembly:
movswq 0x30(%rdi), %rax
movq 0x40(%rdi), %rcx
testb $0x60, 0x40(%rcx)
je 0x26d1b5
movq 0x8(%rcx), %rdx
movq %rax, %rsi
shlq $0x5, %rsi
testb $0x60, 0x1c(%rdx,%rsi)
je 0x26d1b5
movzwl 0x46(%rcx), %ecx
pushq $-0x1
popq %rdx
movq %rdx, %rax
shlq %cl, %rax
cmpw $0x40, %cx
notq %rax
cmovgeq %rdx, %rax
retq
cmpw $0x3f, %ax
pushq $0x3f
popq %rcx
cmovll %eax, %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAddCollateString
SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
  Token s;
  assert( zC!=0 );
  sqlite3TokenInit(&s, (char*)zC);
  return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %rdx, (%r15)
movq %rdx, %rdi
callq 0x2211ac
movl %eax, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x261042
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3AuthReadCol
SQLITE_PRIVATE int sqlite3AuthReadCol(
  Parse *pParse,                  /* The parser context */
  const char *zTab,               /* Table name */
  const char *zCol,               /* Column name */
  int iDb                         /* Index of containing database. */
){
  sqlite3 *db = pParse->db;          /* Database handle */
  char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
  int rc;                            /* Auth callback return code */

  if( db->init.busy ) return SQLITE_OK;
  rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
#ifdef SQLITE_USER_AUTHENTICATION
                 ,db->auth.zAuthUser
#endif
                );
  if( rc==SQLITE_DENY ){
    char *z = sqlite3_mprintf("%s.%s", zTab, zCol);
    if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
    sqlite3ErrorMsg(pParse, "access to %z is prohibited", z);
    pParse->rc = SQLITE_AUTH;
  }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
    sqliteAuthBadReturnCode(pParse);
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
xorl %r13d, %r13d
cmpb $0x0, 0xb5(%r14)
jne 0x26d2d6
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x20(%r14), %rax
movslq %ecx, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %r8
movq 0x1d0(%r14), %rdi
movq 0x160(%rbx), %r9
pushq $0x14
popq %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r8, (%rsp)
callq *0x1c8(%r14)
cmpl $0x1, %eax
jne 0x26d2c4
leaq 0x8787f(%rip), %rdi     # 0x2f4af5
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22132b
testl %ebp, %ebp
jne 0x26d28e
cmpl $0x3, 0x28(%r14)
jl 0x26d2a3
leaq 0x10ad48(%rip), %rdi    # 0x377fdd
movq (%rsp), %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22132b
leaq 0x10ad39(%rip), %rsi    # 0x377fe3
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x226dce
movl $0x17, 0x18(%rbx)
pushq $0x1
popq %r13
jmp 0x26d2d6
movl %eax, %r13d
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
je 0x26d2d6
movq %rbx, %rdi
callq 0x26a6bc
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowFind
static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
  Window *p;
  for(p=pList; p; p=p->pNextWin){
    if( sqlite3StrICmp(p->zName, zName)==0 ) break;
  }
  if( p==0 ){
    sqlite3ErrorMsg(pParse, "no such window: %s", zName);
  }
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rbx, %rbx
je 0x26d310
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x221779
testl %eax, %eax
je 0x26d324
movq 0x40(%rbx), %rbx
jmp 0x26d2f6
leaq 0x10ad6d(%rip), %rsi    # 0x378084
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x226dce
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprSrcCount
static int exprSrcCount(Walker *pWalker, Expr *pExpr){
  /* There was once a NEVER() on the second term on the grounds that
  ** sqlite3FunctionUsesThisSrc() was always called before
  ** sqlite3ExprAnalyzeAggregates() and so the TK_COLUMNs have not yet
  ** been converted into TK_AGG_COLUMN. But this is no longer true due
  ** to window functions - sqlite3WindowRewrite() may now indirectly call
  ** FunctionUsesThisSrc() when creating a new sub-select. */
  if( pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN ){
    int i;
    struct SrcCount *p = pWalker->u.pSrcCount;
    SrcList *pSrc = p->pSrc;
    int nSrc = pSrc ? pSrc->nSrc : 0;
    for(i=0; i<nSrc; i++){
      if( pExpr->iTable==pSrc->a[i].iCursor ) break;
    }
    if( i<nSrc ){
      p->nThis++;
    }else if( pExpr->iTable<p->iSrcInner ){
      /* In a well-formed parse tree (no name resolution errors),
      ** TK_COLUMN nodes with smaller Expr.iTable values are in an
      ** outer context.  Those are the only ones to count as "other" */
      p->nOther++;
    }
  }
  return WRC_Continue;
}

// Assembly:
movzbl (%rsi), %eax
orl $0x2, %eax
cmpl $0xa6, %eax
jne 0x26d37e
movq 0x28(%rdi), %rax
movq (%rax), %rcx
xorl %edx, %edx
movl $0x0, %edi
testq %rcx, %rcx
je 0x26d34f
movl (%rcx), %edi
testl %edi, %edi
cmovlel %edx, %edi
movl 0x2c(%rsi), %esi
imulq $0x70, %rdi, %rdi
addq $0x70, %rdi
leaq 0x70(%rdx), %r8
cmpq %r8, %rdi
je 0x26d376
cmpl 0x48(%rcx,%rdx), %esi
movq %r8, %rdx
jne 0x26d35f
incl 0xc(%rax)
jmp 0x26d37e
cmpl 0x8(%rax), %esi
jge 0x26d37e
incl 0x10(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: selectSrcCount
static int selectSrcCount(Walker *pWalker, Select *pSel){
  struct SrcCount *p = pWalker->u.pSrcCount;
  if( p->iSrcInner==0x7FFFFFFF && ALWAYS(pSel->pSrc) && pSel->pSrc->nSrc ){
    pWalker->u.pSrcCount->iSrcInner = pSel->pSrc->a[0].iCursor;
  }
  return WRC_Continue;
}

// Assembly:
movq 0x28(%rdi), %rax
cmpl $0x7fffffff, 0x8(%rax)  # imm = 0x7FFFFFFF
jne 0x26d3a2
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x26d3a2
cmpl $0x0, (%rcx)
je 0x26d3a2
movl 0x48(%rcx), %ecx
movl %ecx, 0x8(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SelectPrep
SQLITE_PRIVATE void sqlite3SelectPrep(
  Parse *pParse,         /* The parser context */
  Select *p,             /* The SELECT statement being coded. */
  NameContext *pOuterNC  /* Name context for container */
){
  assert( p!=0 || pParse->db->mallocFailed );
  if( pParse->db->mallocFailed ) return;
  if( p->selFlags & SF_HasTypeInfo ) return;
  sqlite3SelectExpand(pParse, p);
  if( pParse->nErr || pParse->db->mallocFailed ) return;
  sqlite3ResolveSelectNames(pParse, p, pOuterNC);
  if( pParse->nErr || pParse->db->mallocFailed ) return;
  sqlite3SelectAddTypeInfo(pParse, p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rax
cmpb $0x0, 0x61(%rax)
jne 0x26d484
movq %rsi, %rbx
testb $-0x80, 0x4(%rsi)
jne 0x26d484
movq %rdx, %r15
movq %rdi, %r14
leaq 0x27b(%rip), %r12       # 0x26d652
movq %r12, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpb $0x0, 0x22(%rdi)
je 0x26d404
leaq 0x267(%rip), %rax       # 0x26d655
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rbx, %rsi
callq 0x268025
leaq 0x389(%rip), %rax       # 0x26d794
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
leaq 0x11f5(%rip), %rax      # 0x26e610
movq %rax, 0x18(%rdi)
andw $0x0, 0x24(%rdi)
movq %rbx, %rsi
callq 0x268025
cmpl $0x0, 0x30(%r14)
jne 0x26d484
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x26d484
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x26d490
cmpl $0x0, 0x30(%r14)
jne 0x26d484
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x26d484
leaq 0x1e03(%rip), %rax      # 0x26f264
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
leaq 0x1df6(%rip), %rax      # 0x26f267
movq %rax, 0x18(%rdi)
movq %r12, 0x8(%rdi)
movq %r14, (%rdi)
movq %rbx, %rsi
callq 0x268025
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: selectPopWith
static void selectPopWith(Walker *pWalker, Select *p){
  Parse *pParse = pWalker->pParse;
  if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
    With *pWith = findRightmost(p)->pWith;
    if( pWith!=0 ){
      assert( pParse->pWith==pWith || pParse->nErr );
      pParse->pWith = pWith->pOuter;
    }
  }
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
cmpq $0x0, 0x190(%rbx)
je 0x26e641
cmpq $0x0, 0x50(%rsi)
jne 0x26e641
movq %rsi, %rdi
callq 0x26f257
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x26e641
movq 0x8(%rax), %rax
movq %rax, 0x190(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3LocateTableItem
SQLITE_PRIVATE Table *sqlite3LocateTableItem(
  Parse *pParse,
  u32 flags,
  struct SrcList_item *p
){
  const char *zDb;
  assert( p->pSchema==0 || p->zDatabase==0 );
  if( p->pSchema ){
    int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
    zDb = pParse->db->aDb[iDb].zDbSName;
  }else{
    zDb = p->zDatabase;
  }
  return sqlite3LocateTable(pParse, flags, p->zName, zDb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x26e6cf
movq (%r15), %r12
movq %r12, %rdi
callq 0x226e9e
cltq
shlq $0x5, %rax
addq 0x20(%r12), %rax
jmp 0x26e6d3
leaq 0x8(%r14), %rax
movq (%rax), %rcx
movq 0x10(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x226b48
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IndexedByLookup
SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
  if( pFrom->pTab && pFrom->fg.isIndexedBy ){
    Table *pTab = pFrom->pTab;
    char *zIndexedBy = pFrom->u1.zIndexedBy;
    Index *pIdx;
    for(pIdx=pTab->pIndex;
        pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
        pIdx=pIdx->pNext
    );
    if( !pIdx ){
      sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
      pParse->checkSchema = 1;
      return SQLITE_ERROR;
    }
    pFrom->pIBIndex = pIdx;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rsi), %r12
xorl %ebp, %ebp
testq %r12, %r12
je 0x26ea28
movq %rsi, %r14
testb $0x2, 0x3d(%rsi)
je 0x26ea28
movq %rdi, %rbx
movq 0x60(%r14), %r15
addq $0x10, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x26ea05
movq (%r12), %rdi
movq %r15, %rsi
callq 0x221779
testl %eax, %eax
je 0x26ea24
addq $0x28, %r12
jmp 0x26e9e6
leaq 0x1098ac(%rip), %rsi    # 0x3782b8
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x226dce
movb $0x1, 0x1d(%rbx)
pushq $0x1
popq %rbp
jmp 0x26ea28
movq %r12, 0x68(%r14)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: tableAndColumnIndex
static int tableAndColumnIndex(
  SrcList *pSrc,       /* Array of tables to search */
  int N,               /* Number of tables in pSrc->a[] to search */
  const char *zCol,    /* Name of the column we are looking for */
  int *piTab,          /* Write index of pSrc->a[] here */
  int *piCol,          /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
  int bIgnoreHidden    /* True to ignore hidden columns */
){
  int i;               /* For looping over tables in pSrc */
  int iCol;            /* Index of column matching zCol */

  assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
  for(i=0; i<N; i++){
    iCol = columnIndex(pSrc->a[i].pTab, zCol);
    if( iCol>=0
     && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
    ){
      if( piTab ){
        *piTab = i;
        *piCol = iCol;
      }
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r14
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r13d
addq $0x28, %r14
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x26eab2
movq (%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x26f155
testl %eax, %eax
js 0x26ea91
testl %ebp, %ebp
je 0x26ea9a
movq 0x8(%r15), %rcx
movl %eax, %edx
shlq $0x5, %rdx
testb $0x2, 0x1c(%rcx,%rdx)
je 0x26ea9a
incq %rbx
addq $0x70, %r14
jmp 0x26ea65
pushq $0x1
popq %rcx
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x26eab4
movl %ebx, (%rdx)
movq 0x8(%rsp), %rdx
movl %eax, (%rdx)
jmp 0x26eab4
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SetJoinExpr
SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr *p, int iTable){
  while( p ){
    ExprSetProperty(p, EP_FromJoin);
    assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
    ExprSetVVAProperty(p, EP_NoReduce);
    p->iRightJoinTable = (i16)iTable;
    if( p->op==TK_FUNCTION && p->x.pList ){
      int i;
      for(i=0; i<p->x.pList->nExpr; i++){
        sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
      }
    }
    sqlite3SetJoinExpr(p->pLeft, iTable);
    p = p->pRight;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x8
popq %r15
testq %r14, %r14
je 0x26f14b
orb $0x1, 0x4(%r14)
movw %bx, 0x34(%r14)
cmpb $-0x57, (%r14)
jne 0x26f13a
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x26f13a
movq %r15, %r12
xorl %r13d, %r13d
movslq (%rax), %rcx
cmpq %rcx, %r13
jge 0x26f13a
movq (%rax,%r12), %rdi
movl %ebx, %esi
callq 0x26f0e4
incq %r13
movq 0x20(%r14), %rax
addq $0x18, %r12
jmp 0x26f11a
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x26f0e4
movq 0x18(%r14), %r14
jmp 0x26f0f6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: columnIndex
static int columnIndex(Table *pTab, const char *zCol){
  int i;
  u8 h = sqlite3StrIHash(zCol);
  Column *pCol;
  for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
    if( pCol->hName==h && sqlite3StrICmp(pCol->zName, zCol)==0 ) return i;
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x26d05f
movl %eax, %r14d
movq 0x8(%r15), %r12
movswl 0x46(%r15), %r13d
xorl %r15d, %r15d
pushq $-0x1
popq %rbp
cmpl %r13d, %r15d
jge 0x26f1a8
cmpb %r14b, 0x1b(%r12)
jne 0x26f19c
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x221779
testl %eax, %eax
je 0x26f1a5
addq $0x20, %r12
incl %r15d
jmp 0x26f180
movl %r15d, %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_O2/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 $0xa4, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x25bdcc
testq %rax, %rax
je 0x26f252
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 0x26f1fe
orw $-0x1, 0x30(%rax)
jmp 0x26f252
addq %r14, %rdx
addq $0x8, %rdx
movw %bx, 0x30(%rax)
testb $0x60, 0x40(%rcx)
je 0x26f23f
movq 0x8(%rcx), %rsi
movslq %ebx, %rdi
shlq $0x5, %rdi
testb $0x60, 0x1c(%rsi,%rdi)
je 0x26f23f
movzwl 0x46(%rcx), %ecx
pushq $-0x1
popq %rsi
movq %rsi, %rdi
shlq %cl, %rdi
cmpw $0x40, %cx
notq %rdi
cmovgeq %rsi, %rdi
movq %rdi, 0x58(%rdx)
jmp 0x26f252
cmpl $0x3f, %ebx
pushq $0x3f
popq %rcx
cmovll %ebx, %ecx
pushq $0x1
popq %rsi
shlq %cl, %rsi
orq %rsi, 0x58(%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x3b, (%rsi)
jne 0x26f323
movq %rdi, %r14
movl (%rdi), %eax
xorl %ebx, %ebx
testl %eax, %eax
cmovlel %ebx, %eax
movq 0x8(%rsi), %r15
imulq $0x18, %rax, %r12
pushq $0x1
popq %rbp
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x26f323
testb $0x3, 0x19(%r14,%r13)
jne 0x26f319
movq 0x10(%r14,%r13), %rdi
movq %r15, %rsi
callq 0x221763
testl %eax, %eax
je 0x26f321
incl %ebp
addq $0x18, %r13
jmp 0x26f2fb
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x26f476
pushq %rax
movq 0x40(%rsi), %rdi
callq 0x24b9d8
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26f573
movzbl (%rdi), %eax
leaq 0x1022e3(%rip), %rcx    # 0x371850
cmpb $0x0, (%rax,%rcx)
js 0x26f574
retq
cmpb $0x5b, %al
movzbl %al, %ecx
pushq $0x5d
popq %rax
cmovnel %ecx, %eax
pushq $0x1
popq %rdx
xorl %ecx, %ecx
movslq %edx, %rsi
movb (%rdi,%rsi), %r8b
cmpb %al, %r8b
jne 0x26f59e
cmpb %al, 0x1(%rdi,%rsi)
jne 0x26f5a9
incq %rsi
movl %eax, %r8d
movl %esi, %edx
movb %r8b, (%rdi,%rcx)
incq %rcx
incl %edx
jmp 0x26f584
movl %ecx, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
subl %esi, %edx
leaq 0x102297(%rip), %rcx    # 0x371850
movq %rsi, %rax
movl %edx, %r9d
movzbl (%rsi), %r8d
incq %rsi
leal -0x1(%r9), %edx
testb $0x1, (%r8,%rcx)
jne 0x26f5b9
movl %r9d, %r8d
movslq %r9d, %r9
movq %r9, %rdx
testl %r8d, %r8d
jle 0x26f5f3
movzbl -0x2(%rsi,%r8), %r10d
decq %r8
leaq -0x1(%rdx), %r9
testb $0x1, (%r10,%rcx)
jne 0x26f5d7
movq %rax, %rsi
jmp 0x24b168
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rsp), %rdi
andq $0x0, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq %rbx, (%rdi)
leaq 0x29(%rip), %rax        # 0x26f64f
movq %rax, 0x8(%rdi)
leaq 0x30(%rip), %rax        # 0x26f661
movq %rax, 0x10(%rdi)
movb $0x3, 0x11c(%rbx)
callq 0x267f87
movb %bpl, 0x11c(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq (%rdi), %r12
pushq $0x2
popq %rax
cmpl $0x0, 0x30(%r12)
jne 0x26f779
testb $0x20, 0x6(%rsi)
jne 0x26f6c8
movq %rdi, %r15
movq %rsi, (%rsp)
movq 0x20(%rsi), %r14
testq %r14, %r14
je 0x26f6cf
leaq 0x10(%r14), %r13
xorl %ebp, %ebp
movslq (%r14), %rax
cmpq %rax, %rbp
jge 0x26f6cf
movq (%r13), %rdx
testq %rdx, %rdx
je 0x26f6bf
testb $0x3, 0x9(%r13)
jne 0x26f6bf
movq %r12, %rdi
xorl %esi, %esi
callq 0x26ae3e
incq %rbp
addq $0x18, %r13
jmp 0x26f69d
pushq $0x1
jmp 0x26f778
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x26f766
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rbp
xorl %r14d, %r14d
movq %r15, 0x10(%rsp)
movq 0x8(%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %r14
jge 0x26f766
imulq $0x70, %r14, %rbx
movq 0x10(%rbp,%rbx), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x26ae3e
movq 0x48(%rbp,%rbx), %rsi
movq %r15, %rdi
callq 0x267f87
testl %eax, %eax
jne 0x26f776
addq %rbp, %rbx
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
je 0x26f75c
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jge 0x26f75c
movq (%rbx), %rax
movq (%rax,%r13), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x26ae3e
incq %r15
addq $0x10, %r13
jmp 0x26f739
incq %r14
movq 0x10(%rsp), %r15
jmp 0x26f6f6
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x26f788
xorl %eax, %eax
jmp 0x26f779
pushq $0x2
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x68(%rsi), %r12
testq %r12, %r12
je 0x26f800
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
leaq 0x20(%r12), %rbp
xorl %r14d, %r14d
movslq (%r12), %rax
cmpq %rax, %r14
jge 0x26f800
movq (%rbp), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
movq (%rbx), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movq %rsp, %rdx
callq 0x26d3a5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x268025
movq (%rbx), %rdi
movq -0x8(%rbp), %rsi
callq 0x26f80f
incq %r14
addq $0x20, %rbp
jmp 0x26f7af
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x26f87f
pushq %r15
pushq %r14
pushq %r12
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 -0x1f0(%rip), %rax      # 0x26f64f
movq %rax, 0x8(%rdi)
callq 0x268181
leaq 0x10(%rbx), %r15
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x26f874
testb $0x3, 0x9(%r15)
jne 0x26f86b
movq (%r15), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x26ae3e
incq %r12
addq $0x18, %r15
jmp 0x26f84f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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:
testq %rsi, %rsi
je 0x26f93d
movl (%rsi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x18, %rcx, %rcx
addq $0x18, %rcx
xorl %edx, %edx
leaq 0x18(%rdx), %r8
cmpq %r8, %rcx
je 0x26f93c
testb $0x20, 0x19(%rsi,%rdx)
movq %r8, %rdx
je 0x26f8f5
pushq %rax
movb (%rsi,%r8), %al
cmpb $0x3, %al
leaq 0x108d31(%rip), %rcx    # 0x378647
leaq 0x80ca2(%rip), %rdx     # 0x2f05bf
cmoveq %rcx, %rdx
testb %al, %al
cmoveq %rcx, %rdx
leaq 0x108cfd(%rip), %rsi    # 0x37862b
xorl %eax, %eax
callq 0x226dce
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x26e69f
movq %rax, %rbx
movq (%r15), %rdi
movq 0x28(%r12), %rsi
callq 0x21f182
movq %rbx, 0x28(%r12)
testq %rbx, %rbx
je 0x26f979
incl 0x3c(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x26e9bf
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_O2/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
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq 0x18(%rdi), %rsi
movq (%rax), %r12
movq %r12, %rdi
callq 0x22b0a8
movl %eax, 0x4(%rsp)
testq %r15, %r15
je 0x26fa50
leaq 0x8(%r15), %rbx
xorl %ebp, %ebp
cmpl (%r15), %ebp
jge 0x26fa50
cmpb $0x0, 0x10(%r14)
jne 0x26fa12
movq 0x8(%rbx), %r13
testq %r13, %r13
je 0x26f9f7
movq %r12, %rdi
movq %r13, %rsi
callq 0x22b0a8
cmpl %eax, 0x4(%rsp)
jne 0x26fa54
movq %r12, %rdi
movq %r13, %rsi
callq 0x21f26b
andq $0x0, 0x8(%rbx)
movq 0x8(%r14), %rax
movq %rax, (%rbx)
orb $0x40, 0x3d(%rbx)
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x26fe82
testl %eax, %eax
jne 0x26fa70
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x26ff6a
testl %eax, %eax
jne 0x26fa70
testb $0x4, 0x3d(%rbx)
je 0x26fa48
movq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x26fffa
testl %eax, %eax
jne 0x26fa70
incl %ebp
addq $0x70, %rbx
jmp 0x26f9d1
xorl %eax, %eax
jmp 0x26fa73
movq (%r14), %rdi
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rcx
leaq 0x108d9a(%rip), %rsi    # 0x378800
movq %r13, %r8
xorl %eax, %eax
callq 0x226dce
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq