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: sqlite3Analyze
SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
  sqlite3 *db = pParse->db;
  int iDb;
  int i;
  char *z, *zDb;
  Table *pTab;
  Index *pIdx;
  Token *pTableName;
  Vdbe *v;

  /* Read the database schema. If an error occurs, leave an error message
  ** and code in pParse and return NULL. */
  assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    return;
  }

  assert( pName2!=0 || pName1==0 );
  if( pName1==0 ){
    /* Form 1:  Analyze everything */
    for(i=0; i<db->nDb; i++){
      if( i==1 ) continue;  /* Do not analyze the TEMP database */
      analyzeDatabase(pParse, i);
    }
  }else if( pName2->n==0 && (iDb = sqlite3FindDb(db, pName1))>=0 ){
    /* Analyze the schema named as the argument */
    analyzeDatabase(pParse, iDb);
  }else{
    /* Form 3: Analyze the table or index named as an argument */
    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
    if( iDb>=0 ){
      zDb = pName2->n ? db->aDb[iDb].zDbSName : 0;
      z = sqlite3NameFromToken(db, pTableName);
      if( z ){
        if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
          analyzeTable(pParse, pIdx->pTable, pIdx);
        }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
          analyzeTable(pParse, pTab, 0);
        }
        sqlite3DbFree(db, z);
      }
    }
  }
  if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
    sqlite3VdbeAddOp0(v, OP_Expire);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r14
callq 0x24d8f7
testl %eax, %eax
jne 0x264075
testq %r12, %r12
je 0x263fd0
cmpl $0x0, 0x8(%r15)
je 0x263fef
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x26a6d7
testl %eax, %eax
js 0x26406e
cmpl $0x0, 0x8(%r15)
je 0x26400a
movq 0x20(%r14), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq (%rcx,%rax), %r12
jmp 0x26400d
xorl %ebp, %ebp
cmpl 0x28(%r14), %ebp
jge 0x26406e
cmpl $0x1, %ebp
je 0x263feb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x284781
incl %ebp
jmp 0x263fd2
movq %r14, %rdi
movq %r12, %rsi
callq 0x26a866
testl %eax, %eax
js 0x263f9e
movq %rbx, %rdi
movl %eax, %esi
callq 0x284781
jmp 0x26406e
xorl %r12d, %r12d
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x25c0a8
testq %rax, %rax
je 0x26406e
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x24b089
testq %rax, %rax
je 0x264041
movq 0x18(%rax), %rsi
movq %rbx, %rdi
movq %rax, %rdx
jmp 0x26405e
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x226b48
testq %rax, %rax
je 0x264063
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x284819
movq %r14, %rdi
movq %r15, %rsi
callq 0x22d0fc
cmpb $0x0, 0x6a(%r14)
je 0x264082
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x2645be
testq %rax, %rax
je 0x264075
movq %rax, %rdi
movl $0x9e, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2645ec
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WithAdd
SQLITE_PRIVATE With *sqlite3WithAdd(
  Parse *pParse,          /* Parsing context */
  With *pWith,            /* Existing WITH clause, or NULL */
  Token *pName,           /* Name of the common-table */
  ExprList *pArglist,     /* Optional column name list for the table */
  Select *pQuery          /* Query used to initialize the table */
){
  sqlite3 *db = pParse->db;
  With *pNew;
  char *zName;

  /* Check that the CTE name is unique within this WITH clause. If
  ** not, store an error in the Parse structure. */
  zName = sqlite3NameFromToken(pParse->db, pName);
  if( zName && pWith ){
    int i;
    for(i=0; i<pWith->nCte; i++){
      if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
        sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
      }
    }
  }

  if( pWith ){
    sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
    pNew = sqlite3DbRealloc(db, pWith, nByte);
  }else{
    pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
  }
  assert( (pNew!=0 && zName!=0) || db->mallocFailed );

  if( db->mallocFailed ){
    sqlite3ExprListDelete(db, pArglist);
    sqlite3SelectDelete(db, pQuery);
    sqlite3DbFree(db, zName);
    pNew = pWith;
  }else{
    pNew->a[pNew->nCte].pSelect = pQuery;
    pNew->a[pNew->nCte].pCols = pArglist;
    pNew->a[pNew->nCte].zName = zName;
    pNew->a[pNew->nCte].zCteErr = 0;
    pNew->nCte++;
  }

  return pNew;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %rbx
movq %rdi, %rbp
movq (%rdi), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x25c0a8
movq %rax, %r15
testq %rax, %rax
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x2642d1
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x10(%rbx), %r12
leaq 0x11605c(%rip), %r14    # 0x37a2f9
xorl %r13d, %r13d
movslq (%rbx), %rdx
cmpq %rdx, %r13
jge 0x2642eb
movq (%r12), %rsi
movq %r15, %rdi
callq 0x221779
testl %eax, %eax
jne 0x2642c8
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x226dce
incq %r13
addq $0x20, %r12
jmp 0x2642a0
testq %rbx, %rbx
je 0x26436e
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movslq (%rbx), %rdx
shlq $0x5, %rdx
addq $0x30, %rdx
movq (%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x22d1b5
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %r12
cmpb $0x0, 0x61(%r13)
je 0x264336
movq %r13, %rdi
movq %r12, %rsi
callq 0x24b63f
movq %r13, %rdi
movq %r14, %rsi
callq 0x24b6e9
movq %r13, %rdi
movq %r15, %rsi
callq 0x21f26b
jmp 0x26435c
movslq (%rax), %rcx
movq %rcx, %rdx
shlq $0x5, %rdx
movq %r14, 0x20(%rax,%rdx)
movq %r12, 0x18(%rax,%rdx)
movq %r15, 0x10(%rax,%rdx)
andq $0x0, 0x28(%rax,%rdx)
incl %ecx
movl %ecx, (%rax)
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x30
popq %rsi
movq %r13, %rdi
callq 0x2258ed
jmp 0x26430c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowChain
SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){
  if( pWin->zBase ){
    sqlite3 *db = pParse->db;
    Window *pExist = windowFind(pParse, pList, pWin->zBase);
    if( pExist ){
      const char *zErr = 0;
      /* Check for errors */
      if( pWin->pPartition ){
        zErr = "PARTITION clause";
      }else if( pExist->pOrderBy && pWin->pOrderBy ){
        zErr = "ORDER BY clause";
      }else if( pExist->bImplicitFrame==0 ){
        zErr = "frame specification";
      }
      if( zErr ){
        sqlite3ErrorMsg(pParse,
            "cannot override %s of window: %s", zErr, pWin->zBase
        );
      }else{
        pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0);
        if( pExist->pOrderBy ){
          assert( pWin->pOrderBy==0 );
          pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0);
        }
        sqlite3DbFree(db, pWin->zBase);
        pWin->zBase = 0;
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x264439
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq %rdx, %rsi
movq %rax, %rdx
callq 0x26d2e8
testq %rax, %rax
je 0x264439
cmpq $0x0, 0x10(%rbx)
je 0x2643db
leaq 0x115f5c(%rip), %rdx    # 0x37a317
movq 0x8(%rbx), %rcx
leaq 0x115f62(%rip), %rsi    # 0x37a328
movq %r15, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x226dce
movq %rax, %r12
cmpq $0x0, 0x18(%rax)
je 0x2643f5
cmpq $0x0, 0x18(%rbx)
je 0x2643f5
leaq 0x11408a(%rip), %rdx    # 0x37847d
jmp 0x2643bb
cmpb $0x0, 0x23(%r12)
je 0x264445
movq 0x10(%r12), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x269d84
movq %rax, 0x10(%rbx)
movq 0x18(%r12), %rsi
testq %rsi, %rsi
je 0x264428
movq %r14, %rdi
xorl %edx, %edx
callq 0x269d84
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x21f26b
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x115f09(%rip), %rdx    # 0x37a355
jmp 0x2643bb
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowAssemble
SQLITE_PRIVATE Window *sqlite3WindowAssemble(
  Parse *pParse,
  Window *pWin,
  ExprList *pPartition,
  ExprList *pOrderBy,
  Token *pBase
){
  if( pWin ){
    pWin->pPartition = pPartition;
    pWin->pOrderBy = pOrderBy;
    if( pBase ){
      pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n);
    }
  }else{
    sqlite3ExprListDelete(pParse->db, pPartition);
    sqlite3ExprListDelete(pParse->db, pOrderBy);
  }
  return pWin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x264486
movq %rdx, 0x10(%rbx)
movq %r14, 0x18(%rbx)
testq %r8, %r8
je 0x26449c
movq (%r15), %rdi
movq (%r8), %rsi
movl 0x8(%r8), %edx
callq 0x24b168
movq %rax, 0x8(%rbx)
jmp 0x26449c
movq (%r15), %rdi
movq %rdx, %rsi
callq 0x24b63f
movq (%r15), %rdi
movq %r14, %rsi
callq 0x24b63f
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: sqlite3GetVdbe
SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
  if( pParse->pVdbe ){
    return pParse->pVdbe;
  }
  if( pParse->pToplevel==0
   && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
  ){
    pParse->okConstFactor = 1;
  }
  return sqlite3VdbeCreate(pParse);
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2645c8
retq
cmpq $0x0, 0xa0(%rdi)
jne 0x226f47
movq (%rdi), %rax
testb $0x8, 0x5c(%rax)
jne 0x226f47
movb $0x1, 0x23(%rdi)
jmp 0x226f47
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCode
SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
  int inReg;

  assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
  assert( target>0 && target<=pParse->nMem );
  assert( pParse->pVdbe!=0 || pParse->db->mallocFailed );
  if( pParse->pVdbe==0 ) return;
  inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
  if( inReg!=target ){
    u8 op;
    if( ExprHasProperty(pExpr,EP_Subquery) ){
      op = OP_Copy;
    }else{
      op = OP_SCopy;
    }
    sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x26465c
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x264a71
cmpl %ebx, %eax
jne 0x264662
popq %rbx
popq %r14
popq %r15
retq
btl $0x15, 0x4(%r15)
pushq $0x4d
popq %rsi
sbbl $-0x1, %esi
movq 0x10(%r14), %rdi
movl %eax, %edx
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x24d51a
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3TableLock
SQLITE_PRIVATE void sqlite3TableLock(
  Parse *pParse,     /* Parsing context */
  int iDb,           /* Index of the database containing the table to lock */
  Pgno iTab,         /* Root page number of the table to be locked */
  u8 isWriteLock,    /* True for a write lock */
  const char *zName  /* Name of the table to be locked */
){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  int i;
  int nBytes;
  TableLock *p;
  assert( iDb>=0 );

  if( iDb==1 ) return;
  if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
  for(i=0; i<pToplevel->nTableLock; i++){
    p = &pToplevel->aTableLock[i];
    if( p->iDb==iDb && p->iTab==iTab ){
      p->isWriteLock = (p->isWriteLock || isWriteLock);
      return;
    }
  }

  nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
  pToplevel->aTableLock =
      sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
  if( pToplevel->aTableLock ){
    p = &pToplevel->aTableLock[pToplevel->nTableLock++];
    p->iDb = iDb;
    p->iTab = iTab;
    p->isWriteLock = isWriteLock;
    p->zLockName = zName;
  }else{
    pToplevel->nTableLock = 0;
    sqlite3OomFault(pToplevel->db);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xa0(%rdi), %r12
testq %r12, %r12
cmoveq %rdi, %r12
cmpl $0x1, %esi
je 0x26484f
movl %ecx, %ebx
movl %esi, %r15d
movq (%rdi), %rax
movq 0x20(%rax), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rax
cmpb $0x0, 0x11(%rax)
je 0x26484f
movq %r8, %r14
movl %edx, %ebp
movl 0x88(%r12), %ecx
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
imulq $0x18, %rdx, %rdx
cmpq %rax, %rdx
je 0x2647f5
movq 0x90(%r12), %rsi
cmpl %r15d, (%rsi,%rax)
jne 0x2647ef
cmpl %ebp, 0x4(%rsi,%rax)
je 0x264846
addq $0x18, %rax
jmp 0x2647d6
imull $0x18, %ecx, %eax
addl $0x18, %eax
movq (%r12), %rdi
movq 0x90(%r12), %rsi
movslq %eax, %rdx
callq 0x23a149
movq %rax, 0x90(%r12)
testq %rax, %rax
je 0x264858
movslq 0x88(%r12), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x88(%r12)
imulq $0x18, %rcx, %rcx
movl %r15d, (%rax,%rcx)
movl %ebp, 0x4(%rax,%rcx)
movb %bl, 0x8(%rax,%rcx)
movq %r14, 0x10(%rax,%rcx)
jmp 0x26484f
orb 0x8(%rsi,%rax), %bl
setne 0x8(%rsi,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andl $0x0, 0x88(%r12)
movq (%r12), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x224bb1
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeSetP4KeyInfo
SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
  Vdbe *v = pParse->pVdbe;
  KeyInfo *pKeyInfo;
  assert( v!=0 );
  assert( pIdx!=0 );
  pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
  if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
callq 0x264892
testq %rax, %rax
je 0x264890
pushq $-0x9
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x26495f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3KeyInfoOfIndex
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
  int i;
  int nCol = pIdx->nColumn;
  int nKey = pIdx->nKeyCol;
  KeyInfo *pKey;
  if( pParse->nErr ) return 0;
  if( pIdx->uniqNotNull ){
    pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
  }else{
    pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
  }
  if( pKey ){
    assert( sqlite3KeyInfoIsWriteable(pKey) );
    for(i=0; i<nCol; i++){
      const char *zColl = pIdx->azColl[i];
      pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
                        sqlite3LocateCollSeq(pParse, zColl);
      pKey->aSortFlags[i] = pIdx->aSortOrder[i];
      assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
    }
    if( pParse->nErr ){
      assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
      if( pIdx->bNoQuery==0 ){
        /* Deactivate the index because it contains an unknown collating
        ** sequence.  The only way to reactive the index is to reload the
        ** schema.  Adding the missing collating sequence later does not
        ** reactive the index.  The application had the chance to register
        ** the missing index using the collation-needed callback.  For
        ** simplicity, SQLite will not give the application a second chance.
        */
        pIdx->bNoQuery = 1;
        pParse->rc = SQLITE_ERROR_RETRY;
      }
      sqlite3KeyInfoUnref(pKey);
      pKey = 0;
    }
  }
  return pKey;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x30(%rdi)
je 0x2648b8
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x60(%rsi), %ebp
testb $0x8, 0x63(%rsi)
movq (%rdi), %rdi
jne 0x2648d1
movl %ebp, %esi
xorl %edx, %edx
jmp 0x2648da
movzwl 0x5e(%r14), %esi
movl %ebp, %edx
subl %esi, %edx
callq 0x264994
movq %rax, %r15
testq %rax, %rax
je 0x2648a3
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x10d67c(%rip), %rbp    # 0x371f70
cmpq %r13, %r12
je 0x26492c
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rsi
cmpq %rbp, %rsi
je 0x264910
movq %rbx, %rdi
callq 0x264a12
jmp 0x264912
xorl %eax, %eax
movq %rax, 0x20(%r15,%r13,8)
movq 0x38(%r14), %rax
movb (%rax,%r13), %al
movq 0x18(%r15), %rcx
movb %al, (%rcx,%r13)
incq %r13
jmp 0x2648f4
cmpl $0x0, 0x30(%rbx)
je 0x2648a6
movzwl 0x63(%r14), %eax
btl $0x8, %eax
jb 0x264952
orl $0x100, %eax            # imm = 0x100
movw %ax, 0x63(%r14)
movl $0x201, 0x18(%rbx)      # imm = 0x201
movq %r15, %rdi
callq 0x2387e9
jmp 0x2648a3
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeAppendP4
SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){
  VdbeOp *pOp;
  assert( n!=P4_INT32 && n!=P4_VTAB );
  assert( n<=0 );
  if( p->db->mallocFailed ){
    freeP4(p->db, n, pP4);
  }else{
    assert( pP4!=0 );
    assert( p->nOp>0 );
    pOp = &p->aOp[p->nOp-1];
    assert( pOp->p4type==P4_NOTUSED );
    pOp->p4type = n;
    pOp->p4.p = pP4;
  }
}

// Assembly:
movq %rsi, %rax
movq (%rdi), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x264978
movq %rcx, %rdi
movl %edx, %esi
movq %rax, %rdx
jmp 0x238761
movq 0x88(%rdi), %rcx
movslq 0x90(%rdi), %rsi
imulq $0x18, %rsi, %rsi
movb %dl, -0x17(%rcx,%rsi)
movq %rax, -0x8(%rcx,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3KeyInfoAlloc
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
  int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*);
  KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra);
  if( p ){
    p->aSortFlags = (u8*)&p->aColl[N+X];
    p->nKeyField = (u16)N;
    p->nAllField = (u16)(N+X);
    p->enc = ENC(db);
    p->db = db;
    p->nRef = 1;
    memset(&p[1], 0, nExtra);
  }else{
    sqlite3OomFault(db);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
addl %esi, %r12d
leal (%r12,%r12,8), %eax
addl $-0x8, %eax
movslq %eax, %r15
leaq 0x28(%r15), %rsi
callq 0x22d205
movq %rax, %rbx
testq %rax, %rax
je 0x2649fe
movslq %r12d, %rax
leaq (%rbx,%rax,8), %rax
addq $0x20, %rax
movq %rax, 0x18(%rbx)
movw %bp, 0x6(%rbx)
movw %r12w, 0x8(%rbx)
movb 0x5e(%r14), %al
movb %al, 0x4(%rbx)
movq %r14, 0x10(%rbx)
movl $0x1, (%rbx)
movq %rbx, %rdi
addq $0x28, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x17380
jmp 0x264a06
movq %r14, %rdi
callq 0x224bb1
movq %rbx, %rax
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: sqlite3TableColumnToStorage
SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
  int i;
  i16 n;
  assert( iCol<pTab->nCol );
  if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
  for(i=0, n=0; i<iCol; i++){
    if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
  }
  if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
    /* iCol is a virtual column itself */
    return pTab->nNVCol + i - n;
  }else{
    /* iCol is a normal or stored column */
    return n;
  }
}

// Assembly:
movl %esi, %eax
testw %ax, %ax
js 0x265db0
movl 0x40(%rdi), %ecx
andl $0x20, %ecx
je 0x265db0
movzwl %ax, %ecx
movq 0x8(%rdi), %rdx
movl %ecx, %r8d
shll $0x5, %r8d
xorl %r9d, %r9d
xorl %esi, %esi
cmpq %r9, %r8
je 0x265da4
movb 0x1c(%rdx,%r9), %r10b
andb $0x20, %r10b
cmpb $0x1, %r10b
adcw $0x0, %si
addq $0x20, %r9
jmp 0x265d88
shll $0x5, %ecx
testb $0x20, 0x1c(%rdx,%rcx)
jne 0x265db1
movl %esi, %eax
retq
subl %esi, %eax
addw 0x48(%rdi), %ax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCodeGeneratedColumn
SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(
  Parse *pParse,
  Column *pCol,
  int regOut
){
  int iAddr;
  Vdbe *v = pParse->pVdbe;
  assert( v!=0 );
  assert( pParse->iSelfTab!=0 );
  if( pParse->iSelfTab>0 ){
    iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut);
  }else{
    iAddr = 0;
  }
  sqlite3ExprCodeCopy(pParse, pCol->pDflt, regOut);
  if( pCol->affinity>=SQLITE_AFF_TEXT ){
    sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1);
  }
  if( iAddr ) sqlite3VdbeJumpHere(v, iAddr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
movq 0x10(%rdi), %rbx
movl 0x40(%rdi), %edx
testl %edx, %edx
jle 0x265dee
decl %edx
pushq $0x15
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x24d51f
movl %eax, %r15d
jmp 0x265df1
xorl %r15d, %r15d
movq 0x8(%r14), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0x267657
cmpb $0x42, 0x19(%r14)
jl 0x265e27
addq $0x19, %r14
movl $0x1, (%rsp)
pushq $0x5a
popq %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %ebp, %edx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x264609
testl %r15d, %r15d
je 0x265e43
movq %rbx, %rdi
movl %r15d, %esi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2645f8
addq $0x10, %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: codeInteger
static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
  Vdbe *v = pParse->pVdbe;
  if( pExpr->flags & EP_IntValue ){
    int i = pExpr->u.iValue;
    assert( i>=0 );
    if( negFlag ) i = -i;
    sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
  }else{
    int c;
    i64 value;
    const char *z = pExpr->u.zToken;
    assert( z!=0 );
    c = sqlite3DecOrHexToI64(z, &value);
    if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){
#ifdef SQLITE_OMIT_FLOATING_POINT
      sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
#else
#ifndef SQLITE_OMIT_HEX_INTEGER
      if( sqlite3_strnicmp(z,"0x",2)==0 ){
        sqlite3ErrorMsg(pParse, "hex literal too big: %s%s", negFlag?"-":"",z);
      }else
#endif
      {
        codeReal(v, z, negFlag, iMem);
      }
#endif
    }else{
      if( negFlag ){ value = c==3 ? SMALLEST_INT64 : -value; }
      sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq 0x10(%rdi), %r14
testb $0x4, 0x5(%rsi)
jne 0x265ee0
movq %rdi, %r15
movq 0x8(%rsi), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x22cdef
movl %eax, %ecx
xorl $0x3, %ecx
orl %ebp, %ecx
setne %cl
cmpl $0x2, %eax
je 0x265eaf
testb %cl, %cl
je 0x265eaf
testl %ebp, %ebp
setne %dl
movq 0x8(%rsp), %rcx
negq %rcx
seto %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x265f39
leaq 0x111b77(%rip), %rsi    # 0x377a2d
pushq $0x2
popq %rdx
movq %r12, %rdi
callq 0x2217ad
testl %eax, %eax
je 0x265f05
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ebx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x265f8b
movl 0x8(%rsi), %eax
movl %eax, %edx
negl %edx
testl %ebp, %ebp
cmovel %eax, %edx
pushq $0x45
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x24d51a
testl %ebp, %ebp
leaq 0x10229c(%rip), %rax    # 0x3681aa
leaq 0x10465b(%rip), %rdx    # 0x36a570
cmovneq %rax, %rdx
leaq 0x111b10(%rip), %rsi    # 0x377a30
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x226dce
testl %ebp, %ebp
je 0x265f53
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
cmpl $0x3, %eax
cmoveq %rdx, %rcx
movq %rcx, 0x8(%rsp)
pushq $0x46
popq %rsi
leaq 0x8(%rsp), %rcx
pushq $-0xe
popq %r8
movq %r14, %rdi
movl %ebx, %edx
callq 0x267c12
addq $0x10, %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: codeReal
static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
  if( ALWAYS(z!=0) ){
    double value;
    sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
    assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
    if( negateFlag ) value = -value;
    sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x265fed
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2211ac
movq %rsp, %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
movl %eax, %edx
callq 0x23a955
testl %ebp, %ebp
je 0x265fcd
movsd (%rsp), %xmm0
xorps 0x89a87(%rip), %xmm0    # 0x2efa50
movlps %xmm0, (%rsp)
movq %rsp, %rcx
pushq $-0xd
popq %r8
movq %r14, %rdi
movl $0x96, %esi
movl %ebx, %edx
callq 0x267c12
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCodeTemp
SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
  int r2;
  pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
  if( ConstFactorOk(pParse)
   && pExpr->op!=TK_REGISTER
   && sqlite3ExprIsConstantNotJoin(pExpr)
  ){
    *pReg  = 0;
    r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
  }else{
    int r1 = sqlite3GetTempReg(pParse);
    r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
    if( r2==r1 ){
      *pReg = r1;
    }else{
      sqlite3ReleaseTempReg(pParse, r1);
      *pReg = 0;
    }
  }
  return r2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x267d34
movq %rax, %r15
cmpb $0x0, 0x23(%r14)
je 0x266217
cmpb $-0x53, (%r15)
je 0x266217
movq %r15, %rdi
callq 0x26631b
testl %eax, %eax
je 0x266217
andl $0x0, (%rbx)
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x266325
movq %r14, %rdi
callq 0x267d61
movl %eax, %ebp
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x264a71
cmpl %ebp, %eax
jne 0x266236
movl %ebp, %ecx
jmp 0x266256
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x266256
movzbl 0x1f(%r14), %edx
cmpq $0x7, %rdx
ja 0x266256
leal 0x1(%rdx), %esi
movb %sil, 0x1f(%r14)
movl %ebp, 0xd4(%r14,%rdx,4)
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeCompare
static int codeCompare(
  Parse *pParse,    /* The parsing (and code generating) context */
  Expr *pLeft,      /* The left operand */
  Expr *pRight,     /* The right operand */
  int opcode,       /* The comparison opcode */
  int in1, int in2, /* Register holding operands */
  int dest,         /* Jump here if true.  */
  int jumpIfNull,   /* If true, jump if either operand is NULL */
  int isCommuted    /* The comparison has been commuted */
){
  int p5;
  int addr;
  CollSeq *p4;

  if( pParse->nErr ) return 0;
  if( isCommuted ){
    p4 = sqlite3BinaryCompareCollSeq(pParse, pRight, pLeft);
  }else{
    p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
  }
  p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
  addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
                           (void*)p4, P4_COLLSEQ);
  sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
  return addr;
}

// Assembly:
cmpl $0x0, 0x30(%rdi)
je 0x26626a
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r14d
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
cmpl $0x0, 0x60(%rsp)
je 0x266299
movq %r12, %rsi
movq %r13, %rdx
jmp 0x26629f
movq %r13, %rsi
movq %r12, %rdx
callq 0x24e4fd
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0x267d81
movsbl %al, %esi
movq %r13, %rdi
callq 0x267e25
movl %eax, %r12d
movq 0x10(%rbx), %rdi
movl $0xfffffffe, (%rsp)     # imm = 0xFFFFFFFE
movl %r15d, %esi
movl %r14d, %edx
movl 0x50(%rsp), %ecx
movl %ebp, %r8d
movq 0x10(%rsp), %r9
callq 0x264609
movq 0x10(%rbx), %rax
movslq 0x90(%rax), %rcx
testq %rcx, %rcx
jle 0x26630c
movl 0x58(%rsp), %edx
orb %dl, %r12b
movzbl %r12b, %edx
movq 0x88(%rax), %rax
imulq $0x18, %rcx, %rcx
movw %dx, -0x16(%rax,%rcx)
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: sqlite3GetTempRange
SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){
  int i, n;
  if( nReg==1 ) return sqlite3GetTempReg(pParse);
  i = pParse->iRangeReg;
  n = pParse->nRangeReg;
  if( nReg<=n ){
    pParse->iRangeReg += nReg;
    pParse->nRangeReg -= nReg;
  }else{
    i = pParse->nMem+1;
    pParse->nMem += nReg;
  }
  return i;
}

// Assembly:
cmpl $0x1, %esi
je 0x267d61
movl 0x28(%rdi), %ecx
subl %esi, %ecx
jge 0x2664ae
movl 0x38(%rdi), %ecx
leal 0x1(%rcx), %eax
addl %ecx, %esi
movl %esi, 0x38(%rdi)
retq
movl 0x2c(%rdi), %eax
addl %eax, %esi
movl %esi, 0x2c(%rdi)
movl %ecx, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeAddFunctionCall
SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall(
  Parse *pParse,        /* Parsing context */
  int p1,               /* Constant argument mask */
  int p2,               /* First argument register */
  int p3,               /* Register into which results are written */
  int nArg,             /* Number of argument */
  const FuncDef *pFunc, /* The function to be invoked */
  int eCallCtx          /* Calling context */
){
  Vdbe *v = pParse->pVdbe;
  int nByte;
  int addr;
  sqlite3_context *pCtx;
  assert( v );
  nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
  pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
  if( pCtx==0 ){
    assert( pParse->db->mallocFailed );
    freeEphemeralFunction(pParse->db, (FuncDef*)pFunc);
    return 0;
  }
  pCtx->pOut = 0;
  pCtx->pFunc = (FuncDef*)pFunc;
  pCtx->pVdbe = 0;
  pCtx->isError = 0;
  pCtx->argc = nArg;
  pCtx->iOp = sqlite3VdbeCurrentAddr(v);
  addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function,
                           p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
  sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef);
  return addr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movl %r8d, %r13d
movl %ecx, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %esi, %r15d
movq %rdi, %rbp
movl 0x50(%rsp), %r14d
movq (%rdi), %rdi
movq 0x10(%rbp), %rbx
leal 0x30(,%r13,8), %eax
movslq %eax, %rsi
callq 0x22d205
testq %rax, %rax
je 0x2666c5
andq $0x0, (%rax)
movq %r12, 0x8(%rax)
andq $0x0, 0x18(%rax)
andl $0x0, 0x24(%rax)
movb %r13b, 0x29(%rax)
movl 0x90(%rbx), %ecx
movl %ecx, 0x20(%rax)
xorl %esi, %esi
cmpl $0x1, %r14d
adcl $0x3f, %esi
movl $0xfffffff0, (%rsp)     # imm = 0xFFFFFFF0
movq %rbx, %rdi
movl %r15d, %edx
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %r8d
movq %rax, %r9
callq 0x264609
movslq 0x90(%rbx), %rax
testq %rax, %rax
jle 0x2666b6
andl $0x2e, %r14d
movq 0x88(%rbx), %rcx
imulq $0x18, %rax, %rax
movw %r14w, -0x16(%rcx,%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbp), %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2387ff
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ReleaseTempRange
SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
  if( nReg==1 ){
    sqlite3ReleaseTempReg(pParse, iReg);
    return;
  }
  sqlite3VdbeReleaseRegisters(pParse, iReg, nReg, 0, 0);
  if( nReg>pParse->nRangeReg ){
    pParse->nRangeReg = nReg;
    pParse->iRangeReg = iReg;
  }
}

// Assembly:
cmpl $0x1, %edx
jne 0x266705
testl %esi, %esi
je 0x266713
movzbl 0x1f(%rdi), %eax
cmpq $0x7, %rax
ja 0x266713
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rdi)
leaq (%rdi,%rax,4), %rdi
addq $0xd4, %rdi
jmp 0x266711
cmpl %edx, 0x28(%rdi)
jge 0x266713
movl %edx, 0x28(%rdi)
addq $0x2c, %rdi
movl %esi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprVectorSize
SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){
  u8 op = pExpr->op;
  if( op==TK_REGISTER ) op = pExpr->op2;
  if( op==TK_VECTOR ){
    return pExpr->x.pList->nExpr;
  }else if( op==TK_SELECT ){
    return pExpr->x.pSelect->pEList->nExpr;
  }else{
    return 1;
  }
}

// Assembly:
movb (%rdi), %al
cmpb $-0x53, %al
jne 0x266986
movb 0x2(%rdi), %al
cmpb $-0x52, %al
je 0x266998
movzbl %al, %eax
cmpl $0x88, %eax
jne 0x26699f
movq 0x20(%rdi), %rdi
movq 0x20(%rdi), %rax
movl (%rax), %eax
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprToRegister
static void exprToRegister(Expr *pExpr, int iReg){
  Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
  p->op2 = p->op;
  p->op = TK_REGISTER;
  p->iTable = iReg;
  ExprClearProperty(p, EP_Skip);
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x267d34
movb (%rax), %cl
movb %cl, 0x2(%rax)
movb $-0x53, (%rax)
movl %ebx, 0x2c(%rax)
andb $-0x11, 0x5(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprCodeVector
static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){
  int iResult;
  int nResult = sqlite3ExprVectorSize(p);
  if( nResult==1 ){
    iResult = sqlite3ExprCodeTemp(pParse, p, piFreeable);
  }else{
    *piFreeable = 0;
    if( p->op==TK_SELECT ){
#if SQLITE_OMIT_SUBQUERY
      iResult = 0;
#else
      iResult = sqlite3CodeSubselect(pParse, p);
#endif
    }else{
      int i;
      iResult = pParse->nMem+1;
      pParse->nMem += nResult;
      for(i=0; i<nResult; i++){
        sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
      }
    }
  }
  return iResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26697d
cmpl $0x1, %eax
jne 0x2671fc
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2661cb
andl $0x0, (%r15)
cmpb $-0x78, (%rbx)
jne 0x26721e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26672d
movl 0x38(%r14), %ecx
leal 0x1(%rcx), %ebp
addl %eax, %ecx
movl %ecx, 0x38(%r14)
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %eax
imulq $0x18, %rax, %r13
movl %ebp, %r15d
cmpq %r12, %r13
je 0x26725d
movq 0x20(%rbx), %rax
movq 0x8(%rax,%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x26a287
incl %r15d
addq $0x18, %r12
jmp 0x26723b
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: sqlite3ExprCodeCopy
SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
  sqlite3 *db = pParse->db;
  pExpr = sqlite3ExprDup(db, pExpr, 0);
  if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
  sqlite3ExprDelete(db, pExpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %r14
movq (%rdi), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x267197
movq %rax, %r15
cmpb $0x0, 0x61(%rbx)
jne 0x267686
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x26463f
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24b639
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprSkipCollate
SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
  while( pExpr && ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
    pExpr = pExpr->pLeft;
  }
  return pExpr;
}

// Assembly:
movq %rdi, %rax
testq %rax, %rax
je 0x267c7b
testb $0x10, 0x5(%rax)
je 0x267c7b
movq 0x10(%rax), %rax
jmp 0x267c6a
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprVectorRegister
static int exprVectorRegister(
  Parse *pParse,                  /* Parse context */
  Expr *pVector,                  /* Vector to extract element from */
  int iField,                     /* Field to extract from pVector */
  int regSelect,                  /* First in array of registers */
  Expr **ppExpr,                  /* OUT: Expression element */
  int *pRegFree                   /* OUT: Temp register to free */
){
  u8 op = pVector->op;
  assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT );
  if( op==TK_REGISTER ){
    *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField);
    return pVector->iTable+iField;
  }
  if( op==TK_SELECT ){
    *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
     return regSelect+iField;
  }
  *ppExpr = pVector->x.pList->a[iField].pExpr;
  return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movl %edx, %ebx
movq %rsi, %r15
movzbl (%rsi), %eax
cmpl $0x88, %eax
je 0x267cb9
cmpl $0xad, %eax
jne 0x267cda
movq %r15, %rdi
movl %ebx, %esi
callq 0x267cfa
movq %rax, (%r14)
addl 0x2c(%r15), %ebx
jmp 0x267cd2
movq 0x20(%r15), %rax
movq 0x20(%rax), %rax
movslq %ebx, %rdx
imulq $0x18, %rdx, %rdx
movq 0x8(%rax,%rdx), %rax
movq %rax, (%r14)
addl %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%r15), %rax
movslq %ebx, %rcx
imulq $0x18, %rcx, %rcx
movq 0x8(%rax,%rcx), %rsi
movq %rsi, (%r14)
movq %r9, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2661cb
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VectorFieldSubexpr
SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){
  assert( i<sqlite3ExprVectorSize(pVector) );
  if( sqlite3ExprIsVector(pVector) ){
    assert( pVector->op2==0 || pVector->op==TK_REGISTER );
    if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){
      return pVector->x.pSelect->pEList->a[i].pExpr;
    }else{
      return pVector->x.pList->a[i].pExpr;
    }
  }
  return pVector;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2661b9
testl %eax, %eax
je 0x267d2a
cmpb $-0x78, (%rbx)
je 0x267d16
cmpb $-0x78, 0x2(%rbx)
jne 0x267d1a
movq 0x20(%rbx), %rbx
movq 0x20(%rbx), %rax
movslq %ebp, %rcx
imulq $0x18, %rcx, %rcx
movq 0x8(%rax,%rcx), %rbx
movq %rbx, %rax
addq $0x8, %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: sqlite3ExprSkipCollateAndLikely
SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
  while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
    if( ExprHasProperty(pExpr, EP_Unlikely) ){
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      assert( pExpr->x.pList->nExpr>0 );
      assert( pExpr->op==TK_FUNCTION );
      pExpr = pExpr->x.pList->a[0].pExpr;
    }else{
      assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
      pExpr = pExpr->pLeft;
    }
  }
  return pExpr;
}

// Assembly:
movq %rdi, %rax
testq %rax, %rax
je 0x267d60
movl 0x4(%rax), %ecx
testl $0x41000, %ecx          # imm = 0x41000
je 0x267d60
btl $0x12, %ecx
jb 0x267d53
addq $0x10, %rax
jmp 0x267d5b
movq 0x20(%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
jmp 0x267d37
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAffinity
SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
  int op;
  while( ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
    pExpr = pExpr->pLeft;
    assert( pExpr!=0 );
  }
  op = pExpr->op;
  if( op==TK_SELECT ){
    assert( pExpr->flags&EP_xIsSelect );
    assert( pExpr->x.pSelect!=0 );
    assert( pExpr->x.pSelect->pEList!=0 );
    assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
    return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
  }
  if( op==TK_REGISTER ) op = pExpr->op2;
#ifndef SQLITE_OMIT_CAST
  if( op==TK_CAST ){
    assert( !ExprHasProperty(pExpr, EP_IntValue) );
    return sqlite3AffinityType(pExpr->u.zToken, 0);
  }
#endif
  if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){
    return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
  }
  if( op==TK_SELECT_COLUMN ){
    assert( pExpr->pLeft->flags&EP_xIsSelect );
    return sqlite3ExprAffinity(
        pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
    );
  }
  if( op==TK_VECTOR ){
    return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
  }
  return pExpr->affExpr;
}

// Assembly:
testb $0x10, 0x5(%rdi)
jne 0x267da2
movzbl (%rdi), %eax
cmpl $0xad, %eax
je 0x267da8
cmpl $0x88, %eax
jne 0x267dab
movq 0x20(%rdi), %rax
movq 0x20(%rax), %rdi
jmp 0x267df3
addq $0x10, %rdi
jmp 0x267df7
movb 0x2(%rdi), %al
cmpb $0x24, %al
je 0x267dfc
movl %eax, %ecx
andb $-0x3, %cl
cmpb $-0x5c, %cl
jne 0x267dc2
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
jne 0x267e0b
cmpb $-0x52, %al
je 0x267def
movzbl %al, %eax
cmpl $0xaf, %eax
jne 0x267e07
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movswq 0x30(%rdi), %rcx
imulq $0x18, %rcx, %rcx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
jmp 0x267df7
movq 0x20(%rdi), %rdi
addq $0x8, %rdi
movq (%rdi), %rdi
jmp 0x267d81
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x266062
movb 0x1(%rdi), %al
retq
movswq 0x30(%rdi), %rax
testq %rax, %rax
js 0x267e22
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movb 0x19(%rcx,%rax), %al
retq
movb $0x44, %al
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CompareAffinity
SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){
  char aff1 = sqlite3ExprAffinity(pExpr);
  if( aff1>SQLITE_AFF_NONE && aff2>SQLITE_AFF_NONE ){
    /* Both sides of the comparison are columns. If one has numeric
    ** affinity, use that. Otherwise use no affinity.
    */
    if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
      return SQLITE_AFF_NUMERIC;
    }else{
      return SQLITE_AFF_BLOB;
    }
  }else{
    /* One side is a column, the other is not. Use the columns affinity. */
    assert( aff1<=SQLITE_AFF_NONE || aff2<=SQLITE_AFF_NONE );
    return (aff1<=SQLITE_AFF_NONE ? aff2 : aff1) | SQLITE_AFF_NONE;
  }
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x267d81
cmpb $0x41, %al
setl %cl
cmpb $0x41, %bl
setl %dl
orb %cl, %dl
jne 0x267e53
cmpb $0x43, %al
setae %al
addb %al, %al
orb $0x41, %al
cmpb $0x43, %bl
movzbl %al, %ecx
pushq $0x43
popq %rax
cmovbl %ecx, %eax
jmp 0x267e60
cmpb $0x41, %al
movzbl %bl, %ecx
movzbl %al, %eax
cmovll %ecx, %eax
orb $0x40, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprIsConst
static int exprIsConst(Expr *p, int initFlag, int iCur){
  Walker w;
  w.eCode = initFlag;
  w.xExprCallback = exprNodeIsConstant;
  w.xSelectCallback = sqlite3SelectWalkFail;
#ifdef SQLITE_DEBUG
  w.xSelectCallback2 = sqlite3SelectWalkAssert2;
#endif
  w.u.iCur = iCur;
  sqlite3WalkExpr(&w, p);
  return w.eCode;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rax
movq %rsp, %rbx
movw %si, 0x24(%rbx)
leaq 0x27(%rip), %rcx        # 0x267e9f
movq %rcx, 0x8(%rbx)
leaq 0xfb(%rip), %rcx        # 0x267f7e
movq %rcx, 0x10(%rbx)
movl %edx, 0x28(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x267f87
movzwl 0x24(%rbx), %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: walkExpr
static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
  int rc;
  testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
  testcase( ExprHasProperty(pExpr, EP_Reduced) );
  while(1){
    rc = pWalker->xExprCallback(pWalker, pExpr);
    if( rc ) return rc & WRC_Abort;
    if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
      assert( pExpr->x.pList==0 || pExpr->pRight==0 );
      if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
      if( pExpr->pRight ){
        assert( !ExprHasProperty(pExpr, EP_WinFunc) );
        pExpr = pExpr->pRight;
        continue;
      }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        assert( !ExprHasProperty(pExpr, EP_WinFunc) );
        if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
      }else{
        if( pExpr->x.pList ){
          if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
        }
#ifndef SQLITE_OMIT_WINDOWFUNC
        if( ExprHasProperty(pExpr, EP_WinFunc) ){
          if( walkWindowList(pWalker, pExpr->y.pWin) ) return WRC_Abort;
        }
#endif
      }
    }
    break;
  }
  return WRC_Continue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x2
popq %rbx
movq %rsi, %r15
movq %r14, %rdi
callq *0x8(%r14)
testl %eax, %eax
jne 0x268008
movzwl 0x5(%r15), %eax
testw $0x8040, %ax            # imm = 0x8040
jne 0x26801b
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x267fc8
movq %r14, %rdi
callq 0x267f8f
testl %eax, %eax
jne 0x26801d
movq 0x18(%r15), %rsi
testq %rsi, %rsi
jne 0x267f9a
movl 0x4(%r15), %eax
btl $0xb, %eax
movq 0x20(%r15), %rsi
jb 0x26800f
testq %rsi, %rsi
je 0x267ff4
movq %r14, %rdi
callq 0x268181
testl %eax, %eax
jne 0x26801d
movl 0x4(%r15), %eax
btl $0x18, %eax
jae 0x26801b
movq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0x2681c9
jmp 0x268017
andl $0x2, %eax
movl %eax, %ebx
jmp 0x26801d
movq %r14, %rdi
callq 0x268025
testl %eax, %eax
jne 0x26801d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WalkSelect
SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){
  int rc;
  if( p==0 ) return WRC_Continue;
  if( pWalker->xSelectCallback==0 ) return WRC_Continue;
  do{
    rc = pWalker->xSelectCallback(pWalker, p);
    if( rc ) return rc & WRC_Abort;
    if( sqlite3WalkSelectExpr(pWalker, p)
     || sqlite3WalkSelectFrom(pWalker, p)
    ){
      return WRC_Abort;
    }
    if( pWalker->xSelectCallback2 ){
      pWalker->xSelectCallback2(pWalker, p);
    }
    p = p->pPrior;
  }while( p!=0 );
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x268169
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x268169
movq %rsi, %r14
pushq $0x2
popq %rbp
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%r15)
testl %eax, %eax
jne 0x26817a
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x268181
testl %eax, %eax
jne 0x268167
movq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x267f87
testl %eax, %eax
jne 0x268167
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x268181
testl %eax, %eax
jne 0x268167
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x267f87
testl %eax, %eax
jne 0x268167
movq 0x48(%r14), %rsi
movq %r15, %rdi
callq 0x268181
testl %eax, %eax
jne 0x268167
movq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x267f87
testl %eax, %eax
jne 0x268167
movq (%r15), %rax
testq %rax, %rax
je 0x2680fa
cmpb $0x2, 0x11c(%rax)
jb 0x2680fa
movq 0x78(%r14), %rsi
movq %r15, %rdi
callq 0x2681c9
testl %eax, %eax
jne 0x268167
movq 0x28(%r14), %r12
testq %r12, %r12
je 0x268147
movl (%r12), %r13d
addq $0x30, %r12
testl %r13d, %r13d
jle 0x268147
movq (%r12), %rsi
testq %rsi, %rsi
je 0x268125
movq %r15, %rdi
callq 0x268025
testl %eax, %eax
jne 0x268167
testb $0x4, 0x15(%r12)
je 0x26813e
movq 0x38(%r12), %rsi
movq %r15, %rdi
callq 0x268181
testl %eax, %eax
jne 0x268167
decl %r13d
addq $0x70, %r12
jmp 0x26810b
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x268158
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x26804f
jmp 0x268169
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andl $0x2, %eax
movl %eax, %ebx
jmp 0x268169