LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FindIndex
SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
  Index *p = 0;
  int i;
  /* All mutexes are required for schema access.  Make sure we hold them. */
  assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
  for(i=OMIT_TEMPDB; i<db->nDb; i++){
    int j = (i<2) ? i^1 : i;  /* Search TEMP before MAIN */
    Schema *pSchema = db->aDb[j].pSchema;
    assert( pSchema );
    if( zDb && sqlite3DbIsNamed(db, j, zDb)==0 ) continue;
    assert( sqlite3SchemaMutexHeld(db, j, 0) );
    p = sqlite3HashFind(&pSchema->idxHash, zName);
    if( p ) break;
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movl 0x28(%rdi), %ebp
xorl %r15d, %r15d
testl %ebp, %ebp
jle 0x2af791
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq 0x20(%rdi), %r14
decl %ebp
xorl %r12d, %r12d
xorl %esi, %esi
cmpl $0x2, %r15d
setb %sil
xorl %r15d, %esi
movq %rsi, %rax
shlq $0x5, %rax
movq 0x18(%r14,%rax), %r13
testq %rbx, %rbx
je 0x2af75e
movq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x2af7f6
testl %eax, %eax
je 0x2af77d
addq $0x20, %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x2aefdf
movq 0x10(%rax), %r12
testq %r12, %r12
setne %al
jmp 0x2af77f
xorl %eax, %eax
testb %al, %al
jne 0x2af794
leal 0x1(%r15), %eax
cmpl %r15d, %ebp
movl %eax, %r15d
jne 0x2af72f
jmp 0x2af794
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DefaultRowEst
SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
               /*                10,  9,  8,  7,  6 */
  static const LogEst aVal[] = { 33, 32, 30, 28, 26 };
  LogEst *a = pIdx->aiRowLogEst;
  LogEst x;
  int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
  int i;

  /* Indexes with default row estimates should not have stat1 data */
  assert( !pIdx->hasStat1 );

  /* Set the first entry (number of rows in the index) to the estimated
  ** number of rows in the table, or half the number of rows in the table
  ** for a partial index.
  **
  ** 2020-05-27:  If some of the stat data is coming from the sqlite_stat1
  ** table but other parts we are having to guess at, then do not let the
  ** estimated number of rows in the table be less than 1000 (LogEst 99).
  ** Failure to do this can cause the indexes for which we do not have
  ** stat1 data to be ignored by the query planner.
  */
  x = pIdx->pTable->nRowLogEst;
  assert( 99==sqlite3LogEst(1000) );
  if( x<99 ){
    pIdx->pTable->nRowLogEst = x = 99;
  }
  if( pIdx->pPartIdxWhere!=0 ) x -= 10;  assert( 10==sqlite3LogEst(2) );
  a[0] = x;

  /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
  ** 6 and each subsequent value (if any) is 5.  */
  memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
  for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
    a[i] = 23;                    assert( 23==sqlite3LogEst(5) );
  }

  assert( 0==sqlite3LogEst(1) );
  if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %rax
movzwl 0x5e(%rdi), %ebp
cmpw $0x5, %bp
movl $0x5, %r15d
cmovbl %ebp, %r15d
movzwl 0x4a(%rax), %ecx
cmpw $0x62, %cx
jg 0x2af9e2
movw $0x63, 0x4a(%rax)
movw $0x63, %cx
leal -0xa(%rcx), %eax
cmpq $0x0, 0x48(%rbx)
cmovel %ecx, %eax
movw %ax, (%r14)
leaq 0x2(%r14), %rdi
leal (%r15,%r15), %eax
movzwl %ax, %edx
leaq 0x12bc77(%rip), %rsi    # 0x3db67a
callq 0x17660
movzwl 0x5e(%rbx), %eax
cmpw %ax, %r15w
jae 0x2afa35
cmpw $0x5, %bp
movl $0x5, %eax
cmovbl %ebp, %eax
movzwl %ax, %ecx
movw $0x17, 0x2(%r14,%rcx,2)
incq %rcx
movzwl 0x5e(%rbx), %eax
cmpq %rax, %rcx
jb 0x2afa21
cmpb $0x0, 0x62(%rbx)
je 0x2afa45
movzwl %ax, %eax
movw $0x0, (%r14,%rax,2)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3GetInt32
SQLITE_PRIVATE int sqlite3GetInt32(const char *zNum, int *pValue){
  sqlite_int64 v = 0;
  int i, c;
  int neg = 0;
  if( zNum[0]=='-' ){
    neg = 1;
    zNum++;
  }else if( zNum[0]=='+' ){
    zNum++;
  }
#ifndef SQLITE_OMIT_HEX_INTEGER
  else if( zNum[0]=='0'
        && (zNum[1]=='x' || zNum[1]=='X')
        && sqlite3Isxdigit(zNum[2])
  ){
    u32 u = 0;
    zNum += 2;
    while( zNum[0]=='0' ) zNum++;
    for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
      u = u*16 + sqlite3HexToInt(zNum[i]);
    }
    if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
      memcpy(pValue, &u, 4);
      return 1;
    }else{
      return 0;
    }
  }
#endif
  if( !sqlite3Isdigit(zNum[0]) ) return 0;
  while( zNum[0]=='0' ) zNum++;
  for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
    v = v*10 + c;
  }

  /* The longest decimal representation of a 32 bit integer is 10 digits:
  **
  **             1234567890
  **     2^31 -> 2147483648
  */
  testcase( i==10 );
  if( i>10 ){
    return 0;
  }
  testcase( v-neg==2147483647 );
  if( v-neg>2147483647 ){
    return 0;
  }
  if( neg ){
    v = -v;
  }
  *pValue = (int)v;
  return 1;
}

// Assembly:
movzbl (%rdi), %ecx
cmpl $0x2d, %ecx
jne 0x2afbc8
incq %rdi
movq $-0x1, %rdx
jmp 0x2afbf6
cmpl $0x30, %ecx
je 0x2afbd7
cmpl $0x2b, %ecx
jne 0x2afbf4
incq %rdi
jmp 0x2afbf4
movzbl 0x1(%rdi), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x2afbf4
movzbl 0x2(%rdi), %eax
leaq 0x12afd2(%rip), %rdx    # 0x3dabc0
testb $0x8, (%rax,%rdx)
jne 0x2afc69
xorl %edx, %edx
movzbl (%rdi), %r8d
addq $-0x3a, %r8
xorl %eax, %eax
cmpq $-0xa, %r8
jb 0x2afc68
cmpb $0x30, (%rdi)
leaq 0x1(%rdi), %rdi
je 0x2afc06
xorl %r8d, %r8d
xorl %r9d, %r9d
movzbl -0x1(%rdi,%r8), %eax
leal -0x30(%rax), %r10d
cmpb $0x9, %r10b
ja 0x2afc3f
leaq (%r9,%r9,4), %r9
andl $0xf, %eax
leaq (%rax,%r9,2), %r9
incq %r8
cmpq $0xb, %r8
jne 0x2afc15
movl $0xb, %r8d
xorl %eax, %eax
cmpl $0xa, %r8d
ja 0x2afc68
addq %r9, %rdx
cmpq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
jg 0x2afc68
movl %r9d, %r8d
negl %r8d
cmpl $0x2d, %ecx
cmovnel %r9d, %r8d
movl %r8d, (%rsi)
movl $0x1, %eax
retq
addq $0x2, %rdi
cmpb $0x30, (%rdi)
leaq 0x1(%rdi), %rdi
je 0x2afc6d
movzbl -0x1(%rdi), %ecx
movb $0x1, %r9b
xorl %eax, %eax
testb $0x8, (%rcx,%rdx)
movl $0x0, %r8d
je 0x2afcd5
xorl %r9d, %r9d
xorl %r8d, %r8d
movl %r8d, %r10d
shll $0x4, %r10d
leal (%rcx,%rcx), %r8d
sarb $0x7, %r8b
andb $0x9, %r8b
addb %cl, %r8b
andb $0xf, %r8b
movzbl %r8b, %r8d
orl %r10d, %r8d
movzbl (%rdi,%r9), %ecx
movb (%rcx,%rdx), %r10b
cmpq $0x6, %r9
ja 0x2afccd
incq %r9
movl %r10d, %r11d
andb $0x8, %r11b
jne 0x2afc91
testb $0x8, %r10b
sete %r9b
testl %r8d, %r8d
js 0x2afc68
testb %r9b, %r9b
jne 0x2afc60
jmp 0x2afc68
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FreeIndex
SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3 *db, Index *p){
#ifndef SQLITE_OMIT_ANALYZE
  sqlite3DeleteIndexSamples(db, p);
#endif
  sqlite3ExprDelete(db, p->pPartIdxWhere);
  sqlite3ExprListDelete(db, p->aColExpr);
  sqlite3DbFree(db, p->zColAff);
  if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
#ifdef SQLITE_ENABLE_STAT4
  sqlite3_free(p->aiRowEst);
#endif
  sqlite3DbFree(db, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
testq %rsi, %rsi
je 0x2afcfc
movq %r14, %rdi
callq 0x2afd54
movq 0x50(%rbx), %rsi
testq %rsi, %rsi
je 0x2afd0d
movq %r14, %rdi
callq 0x2b0183
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x2afd1e
movq %r14, %rdi
callq 0x28c3e7
testb $0x10, 0x63(%rbx)
je 0x2afd35
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x2afd35
movq %r14, %rdi
callq 0x28c3e7
testq %rbx, %rbx
je 0x2afd4c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3e7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprDeleteNN
static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
  assert( p!=0 );
  /* Sanity check: Assert that the IntValue is non-negative if it exists */
  assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );

  assert( !ExprHasProperty(p, EP_WinFunc) || p->y.pWin!=0 || db->mallocFailed );
  assert( p->op!=TK_FUNCTION || ExprHasProperty(p, EP_TokenOnly|EP_Reduced)
          || p->y.pWin==0 || ExprHasProperty(p, EP_WinFunc) );
#ifdef SQLITE_DEBUG
  if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){
    assert( p->pLeft==0 );
    assert( p->pRight==0 );
    assert( p->x.pSelect==0 );
  }
#endif
  if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){
    /* The Expr.x union is never used at the same time as Expr.pRight */
    assert( p->x.pList==0 || p->pRight==0 );
    if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft);
    if( p->pRight ){
      assert( !ExprHasProperty(p, EP_WinFunc) );
      sqlite3ExprDeleteNN(db, p->pRight);
    }else if( ExprHasProperty(p, EP_xIsSelect) ){
      assert( !ExprHasProperty(p, EP_WinFunc) );
      sqlite3SelectDelete(db, p->x.pSelect);
    }else{
      sqlite3ExprListDelete(db, p->x.pList);
#ifndef SQLITE_OMIT_WINDOWFUNC
      if( ExprHasProperty(p, EP_WinFunc) ){
        sqlite3WindowDelete(db, p->y.pWin);
      }
#endif
    }
  }
  if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
  if( !ExprHasProperty(p, EP_Static) ){
    sqlite3DbFreeNN(db, p);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x5(%rsi), %eax
testl $0x8040, %eax           # imm = 0x8040
jne 0x2afd90
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2afd7f
cmpb $-0x51, (%rbx)
je 0x2afd7f
movq %r14, %rdi
callq 0x2afd54
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2afdc7
movq %r14, %rdi
callq 0x2afd54
testb $0x1, 0x6(%rbx)
je 0x2afda7
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2afda7
movq %r14, %rdi
callq 0x28c3e7
testb $0x8, 0x7(%rbx)
jne 0x2afdbf
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3e7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x8, 0x5(%rbx)
movq 0x20(%rbx), %rsi
jne 0x2afdf2
testq %rsi, %rsi
je 0x2afdde
movq %r14, %rdi
callq 0x2b0183
testb $0x1, 0x7(%rbx)
je 0x2afd90
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2afe06
jmp 0x2afd90
testq %rsi, %rsi
je 0x2afd90
movq %r14, %rdi
movl $0x1, %edx
callq 0x2afecb
jmp 0x2afd90
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowDelete
SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3 *db, Window *p){
  if( p ){
    sqlite3WindowUnlinkFromSelect(p);
    sqlite3ExprDelete(db, p->pFilter);
    sqlite3ExprListDelete(db, p->pPartition);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pEnd);
    sqlite3ExprDelete(db, p->pStart);
    sqlite3DbFree(db, p->zName);
    sqlite3DbFree(db, p->zBase);
    sqlite3DbFree(db, p);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2afeca
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rax
testq %rax, %rax
je 0x2afe42
movq 0x40(%rbx), %rcx
movq %rcx, (%rax)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x2afe3a
movq 0x38(%rbx), %rcx
movq %rcx, 0x38(%rax)
movq $0x0, 0x38(%rbx)
movq 0x48(%rbx), %rsi
testq %rsi, %rsi
je 0x2afe53
movq %r14, %rdi
callq 0x2afd54
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2afe64
movq %r14, %rdi
callq 0x2b0183
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2afe75
movq %r14, %rdi
callq 0x2b0183
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x2afe86
movq %r14, %rdi
callq 0x2afd54
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x2afe97
movq %r14, %rdi
callq 0x2afd54
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x2afea7
movq %r14, %rdi
callq 0x28c3e7
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2afeb8
movq %r14, %rdi
callq 0x28c3e7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3e7
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: clearSelect
static void clearSelect(sqlite3 *db, Select *p, int bFree){
  while( p ){
    Select *pPrior = p->pPrior;
    sqlite3ExprListDelete(db, p->pEList);
    sqlite3SrcListDelete(db, p->pSrc);
    sqlite3ExprDelete(db, p->pWhere);
    sqlite3ExprListDelete(db, p->pGroupBy);
    sqlite3ExprDelete(db, p->pHaving);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pLimit);
#ifndef SQLITE_OMIT_WINDOWFUNC
    if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
      sqlite3WindowListDelete(db, p->pWinDefn);
    }
#endif
    if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
    if( bFree ) sqlite3DbFreeNN(db, p);
    p = pPrior;
    bFree = 1;
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2affb3
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
sete %bpl
movq 0x20(%r14), %rsi
movq 0x50(%r14), %r15
testq %rsi, %rsi
je 0x2afefd
movq %rbx, %rdi
callq 0x2b0183
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x2affb4
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x2aff1a
movq %rbx, %rdi
callq 0x2afd54
movq 0x38(%r14), %rsi
testq %rsi, %rsi
je 0x2aff2b
movq %rbx, %rdi
callq 0x2b0183
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x2aff3c
movq %rbx, %rdi
callq 0x2afd54
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x2aff4d
movq %rbx, %rdi
callq 0x2b0183
movq 0x60(%r14), %rsi
testq %rsi, %rsi
je 0x2aff5e
movq %rbx, %rdi
callq 0x2afd54
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x2aff7b
movq 0x40(%rsi), %r12
movq %rbx, %rdi
callq 0x2afe06
movq %r12, %rsi
testq %r12, %r12
jne 0x2aff67
movq 0x68(%r14), %rsi
testq %rsi, %rsi
je 0x2aff8c
movq %rbx, %rdi
callq 0x2b009d
testb $0x1, %bpl
jne 0x2aff9d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28c3e7
xorl %ebp, %ebp
movq %r15, %r14
testq %r15, %r15
jne 0x2afee8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListDelete
SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
  int i;
  struct SrcList_item *pItem;
  if( pList==0 ) return;
  for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
    sqlite3DbFree(db, pItem->zDatabase);
    sqlite3DbFree(db, pItem->zName);
    sqlite3DbFree(db, pItem->zAlias);
    if( pItem->fg.isIndexedBy ) sqlite3DbFree(db, pItem->u1.zIndexedBy);
    if( pItem->fg.isTabFunc ) sqlite3ExprListDelete(db, pItem->u1.pFuncArg);
    sqlite3DeleteTable(db, pItem->pTab);
    sqlite3SelectDelete(db, pItem->pSelect);
    sqlite3ExprDelete(db, pItem->pOn);
    sqlite3IdListDelete(db, pItem->pUsing);
  }
  sqlite3DbFreeNN(db, pList);
}

// Assembly:
testq %rsi, %rsi
je 0x2b009c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rsi)
jle 0x2b0087
leaq 0x68(%rbx), %r15
xorl %ebp, %ebp
movq -0x58(%r15), %rsi
testq %rsi, %rsi
je 0x2affea
movq %r14, %rdi
callq 0x28c3e7
movq -0x50(%r15), %rsi
testq %rsi, %rsi
je 0x2afffb
movq %r14, %rdi
callq 0x28c3e7
movq -0x48(%r15), %rsi
testq %rsi, %rsi
je 0x2b000c
movq %r14, %rdi
callq 0x28c3e7
testb $0x2, -0x23(%r15)
je 0x2b0023
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2b0023
movq %r14, %rdi
callq 0x28c3e7
testb $0x4, -0x23(%r15)
je 0x2b003a
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2b003a
movq %r14, %rdi
callq 0x2b0183
movq -0x40(%r15), %rsi
movq %r14, %rdi
callq 0x27bd74
movq -0x38(%r15), %rsi
testq %rsi, %rsi
je 0x2b005c
movq %r14, %rdi
movl $0x1, %edx
callq 0x2afecb
movq -0x18(%r15), %rsi
testq %rsi, %rsi
je 0x2b006d
movq %r14, %rdi
callq 0x2afd54
movq -0x10(%r15), %rsi
movq %r14, %rdi
callq 0x2b0119
incl %ebp
addq $0x70, %r15
cmpl (%rbx), %ebp
jl 0x2affd9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28c3e7
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WithDelete
SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){
  if( pWith ){
    int i;
    for(i=0; i<pWith->nCte; i++){
      struct Cte *pCte = &pWith->a[i];
      sqlite3ExprListDelete(db, pCte->pCols);
      sqlite3SelectDelete(db, pCte->pSelect);
      sqlite3DbFree(db, pCte->zName);
    }
    sqlite3DbFree(db, pWith);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2b0118
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rsi)
jle 0x2b0102
leaq 0x20(%rbx), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x2b00cd
movq %r14, %rdi
callq 0x2b0183
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2b00e2
movq %r14, %rdi
movl $0x1, %edx
callq 0x2afecb
movq -0x10(%r15), %rsi
testq %rsi, %rsi
je 0x2b00f3
movq %r14, %rdi
callq 0x28c3e7
incq %r12
movslq (%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x2b00bc
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x28c3e7
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprListDeleteNN
static SQLITE_NOINLINE void exprListDeleteNN(sqlite3 *db, ExprList *pList){
  int i = pList->nExpr;
  struct ExprList_item *pItem =  pList->a;
  assert( pList->nExpr>0 );
  do{
    sqlite3ExprDelete(db, pItem->pExpr);
    sqlite3DbFree(db, pItem->zEName);
    pItem++;
  }while( --i>0 );
  sqlite3DbFreeNN(db, pList);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
leaq 0x8(%rsi), %r15
incl %ebp
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2b01a8
movq %r14, %rdi
callq 0x2afd54
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x2b01b9
movq %r14, %rdi
callq 0x28c3e7
addq $0x18, %r15
decl %ebp
cmpl $0x1, %ebp
jg 0x2b0198
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28c3e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: checkAppendMsg
static void checkAppendMsg(
  IntegrityCk *pCheck,
  const char *zFormat,
  ...
){
  va_list ap;
  if( !pCheck->mxErr ) return;
  pCheck->mxErr--;
  pCheck->nErr++;
  va_start(ap, zFormat);
  if( pCheck->errMsg.nChar ){
    sqlite3_str_append(&pCheck->errMsg, "\n", 1);
  }
  if( pCheck->zPfx ){
    sqlite3_str_appendf(&pCheck->errMsg, pCheck->zPfx, pCheck->v1, pCheck->v2);
  }
  sqlite3_str_vappendf(&pCheck->errMsg, zFormat, ap);
  va_end(ap);
  if( pCheck->errMsg.accError==SQLITE_NOMEM ){
    pCheck->bOomFault = 1;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2b0447
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0x2b04ef
movq %rsi, %r14
movq %rdi, %rbx
decl %eax
movl %eax, 0x1c(%rdi)
incl 0x20(%rdi)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x38(%rdi), %r15
cmpl $0x0, 0x50(%rdi)
je 0x2b04bb
movl 0x50(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl 0x48(%rbx), %ecx
jae 0x2b04a7
movl %ecx, 0x50(%rbx)
movq 0x40(%rbx), %rcx
movb $0xa, (%rcx,%rax)
jmp 0x2b04bb
leaq 0x119271(%rip), %rsi    # 0x3c971f
movq %r15, %rdi
movl $0x1, %edx
callq 0x27e2ca
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x2b04d4
movl 0x30(%rbx), %edx
movl 0x34(%rbx), %ecx
movq %r15, %rdi
xorl %eax, %eax
callq 0x27e729
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x27c5ec
cmpb $0x7, 0x54(%rbx)
jne 0x2b04ef
movl $0x1, 0x24(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: checkPtrmap
static void checkPtrmap(
  IntegrityCk *pCheck,   /* Integrity check context */
  Pgno iChild,           /* Child page number */
  u8 eType,              /* Expected pointer map type */
  Pgno iParent           /* Expected pointer map parent page number */
){
  int rc;
  u8 ePtrmapType;
  Pgno iPtrmapParent;

  rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->bOomFault = 1;
    checkAppendMsg(pCheck, "Failed to read ptrmap key=%d", iChild);
    return;
  }

  if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
    checkAppendMsg(pCheck,
      "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)",
      iChild, eType, iParent, ePtrmapType, iPtrmapParent);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x13(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq 0x298318
testl %eax, %eax
je 0x2b0558
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x2b0532
cmpl $0x7, %eax
jne 0x2b053a
movl $0x1, 0x24(%r14)
leaq 0x12fb09(%rip), %rsi    # 0x3e004a
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2b03ec
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl 0x13(%rsp), %r9d
cmpb %r15b, %r9b
sete %cl
movl 0x14(%rsp), %eax
cmpl %ebp, %eax
sete %dl
testb %dl, %cl
jne 0x2b054d
movzbl %r15b, %ecx
movl %eax, (%rsp)
leaq 0x12fae8(%rip), %rsi    # 0x3e0067
movq %r14, %rdi
movl %ebx, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x2b03ec
jmp 0x2b054d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: checkRef
static int checkRef(IntegrityCk *pCheck, Pgno iPage){
  if( iPage>pCheck->nPage || iPage==0 ){
    checkAppendMsg(pCheck, "invalid page number %d", iPage);
    return 1;
  }
  if( getPageReferenced(pCheck, iPage) ){
    checkAppendMsg(pCheck, "2nd reference to page %d", iPage);
    return 1;
  }
  if( AtomicLoad(&pCheck->db->u1.isInterrupted) ) return 1;
  setPageReferenced(pCheck, iPage);
  return 0;
}

// Assembly:
pushq %rbx
movl %esi, %edx
leal -0x1(%rdx), %eax
cmpl 0x18(%rdi), %eax
jae 0x2b0ddd
movq 0x10(%rdi), %rax
movl %edx, %esi
shrl $0x3, %esi
movzbl (%rax,%rsi), %r8d
movl %edx, %ecx
andb $0x7, %cl
movl $0x1, %r9d
shll %cl, %r9d
movl $0x1, %ebx
movl %edx, %ecx
andl $0x7, %ecx
btl %ecx, %r8d
jae 0x2b0df4
leaq 0x12f25d(%rip), %rsi    # 0x3e0031
xorl %eax, %eax
callq 0x2b03ec
jmp 0x2b0df0
leaq 0x12f236(%rip), %rsi    # 0x3e001a
xorl %eax, %eax
callq 0x2b03ec
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
movq 0x60(%rdi), %rcx
movl 0x168(%rcx), %ecx
testl %ecx, %ecx
jne 0x2b0df0
orb %r8b, %r9b
movb %r9b, (%rax,%rsi)
xorl %ebx, %ebx
jmp 0x2b0df0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RowSetClear
SQLITE_PRIVATE void sqlite3RowSetClear(void *pArg){
  RowSet *p = (RowSet*)pArg;
  struct RowSetChunk *pChunk, *pNextChunk;
  for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
    pNextChunk = pChunk->pNextChunk;
    sqlite3DbFree(p->db, pChunk);
  }
  p->pChunk = 0;
  p->nFresh = 0;
  p->pEntry = 0;
  p->pLast = 0;
  p->pForest = 0;
  p->rsFlags = ROWSET_SORTED;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x2b0e4d
movq (%rsi), %r14
movq 0x8(%rbx), %rdi
callq 0x28c3e7
movq %r14, %rsi
testq %r14, %r14
jne 0x2b0e39
xorl %eax, %eax
movq %rax, (%rbx)
movl $0x10000, 0x30(%rbx)    # imm = 0x10000
movq %rax, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: rowSetEntryAlloc
static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){
  assert( p!=0 );
  if( p->nFresh==0 ){  /*OPTIMIZATION-IF-FALSE*/
    /* We could allocate a fresh RowSetEntry each time one is needed, but it
    ** is more efficient to pull a preallocated entry from the pool */
    struct RowSetChunk *pNew;
    pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew));
    if( pNew==0 ){
      return 0;
    }
    pNew->pNextChunk = p->pChunk;
    p->pChunk = pNew;
    p->pFresh = pNew->aEntry;
    p->nFresh = ROWSET_ENTRY_PER_CHUNK;
  }
  p->nFresh--;
  return p->pFresh++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, 0x30(%rdi)
jne 0x2b0ea1
movq 0x8(%rbx), %rdi
movl $0x3f8, %esi            # imm = 0x3F8
callq 0x28c518
testq %rax, %rax
je 0x2b0eb3
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
addq $0x8, %rax
movq %rax, 0x20(%rbx)
movw $0x2a, 0x30(%rbx)
decw 0x30(%rbx)
movq 0x20(%rbx), %rax
leaq 0x18(%rax), %rcx
movq %rcx, 0x20(%rbx)
popq %rbx
retq
xorl %eax, %eax
jmp 0x2b0eb1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: rowSetEntrySort
static struct RowSetEntry *rowSetEntrySort(struct RowSetEntry *pIn){
  unsigned int i;
  struct RowSetEntry *pNext, *aBucket[40];

  memset(aBucket, 0, sizeof(aBucket));
  while( pIn ){
    pNext = pIn->pRight;
    pIn->pRight = 0;
    for(i=0; aBucket[i]; i++){
      pIn = rowSetEntryMerge(aBucket[i], pIn);
      aBucket[i] = 0;
    }
    aBucket[i] = pIn;
    pIn = pNext;
  }
  pIn = aBucket[0];
  for(i=1; i<sizeof(aBucket)/sizeof(aBucket[0]); i++){
    if( aBucket[i]==0 ) continue;
    pIn = pIn ? rowSetEntryMerge(pIn, aBucket[i]) : aBucket[i];
  }
  return pIn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %r14
movq %rsp, %rbx
movl $0x140, %edx            # imm = 0x140
movq %rbx, %rdi
xorl %esi, %esi
callq 0x173a0
testq %r14, %r14
je 0x2b0f32
movq 0x8(%r14), %r15
movq $0x0, 0x8(%r14)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2b0f23
movl $0x1, %ebp
movq %rbx, %r12
movq %r14, %rsi
callq 0x2b0f6f
movq %rax, %r14
movq $0x0, (%r12)
movl %ebp, %eax
leaq (%rsp,%rax,8), %r12
movq (%r12), %rdi
incl %ebp
testq %rdi, %rdi
jne 0x2b0efd
jmp 0x2b0f26
movq %rbx, %r12
movq %r14, (%r12)
movq %r15, %r14
testq %r15, %r15
jne 0x2b0ee0
movl $0x1, %ebx
movq (%rsp), %rax
movq (%rsp,%rbx,8), %rsi
testq %rsi, %rsi
je 0x2b0f56
testq %rax, %rax
je 0x2b0f53
movq %rax, %rdi
callq 0x2b0f6f
jmp 0x2b0f56
movq %rsi, %rax
incq %rbx
cmpq $0x28, %rbx
jne 0x2b0f3b
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: rowSetNDeepTree
static struct RowSetEntry *rowSetNDeepTree(
  struct RowSetEntry **ppList,
  int iDepth
){
  struct RowSetEntry *p;         /* Root of the new tree */
  struct RowSetEntry *pLeft;     /* Left subtree */
  if( *ppList==0 ){ /*OPTIMIZATION-IF-TRUE*/
    /* Prevent unnecessary deep recursion when we run out of entries */
    return 0;
  }
  if( iDepth>1 ){   /*OPTIMIZATION-IF-TRUE*/
    /* This branch causes a *balanced* tree to be generated.  A valid tree
    ** is still generated without this branch, but the tree is wildly
    ** unbalanced and inefficient. */
    pLeft = rowSetNDeepTree(ppList, iDepth-1);
    p = *ppList;
    if( p==0 ){     /*OPTIMIZATION-IF-FALSE*/
      /* It is safe to always return here, but the resulting tree
      ** would be unbalanced */
      return pLeft;
    }
    p->pLeft = pLeft;
    *ppList = p->pRight;
    p->pRight = rowSetNDeepTree(ppList, iDepth-1);
  }else{
    p = *ppList;
    *ppList = p->pRight;
    p->pLeft = p->pRight = 0;
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x2b10b6
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x2, %esi
jl 0x2b10ba
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x2b1071
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2b10ca
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x2b1071
movq %rax, 0x8(%rbx)
jmp 0x2b10cd
xorl %ebx, %ebx
jmp 0x2b10cd
movq 0x8(%rbx), %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x2b10cd
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: execSqlF
static int execSqlF(sqlite3 *db, char **pzErrMsg, const char *zSql, ...){
  char *z;
  va_list ap;
  int rc;
  va_start(ap, zSql);
  z = sqlite3VMPrintf(db, zSql, ap);
  va_end(ap);
  if( z==0 ) return SQLITE_NOMEM;
  rc = execSql(db, pzErrMsg, z);
  sqlite3DbFree(db, z);
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2b1134
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rax
movq %rsi, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000018, %rcx     # imm = 0x3000000018
movq %rcx, (%rax)
movq %rdx, %rsi
movq %rax, %rdx
callq 0x28e62e
testq %rax, %rax
je 0x2b1184
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2b1268
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x28c3e7
jmp 0x2b1189
movl $0x7, %ebp
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeSetSpillSize
SQLITE_PRIVATE int sqlite3BtreeSetSpillSize(Btree *p, int mxPage){
  BtShared *pBt = p->pBt;
  int res;
  assert( sqlite3_mutex_held(p->db->mutex) );
  sqlite3BtreeEnter(p);
  res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage);
  sqlite3BtreeLeave(p);
  return res;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rcx, 0x8(%rax)
testl %esi, %esi
je 0x2b11d4
movq (%rax), %rax
movq 0x118(%rax), %rcx
jns 0x2b11d1
movslq %esi, %rax
shlq $0xa, %rax
negq %rax
movslq 0x24(%rcx), %rdx
movslq 0x28(%rcx), %rsi
addq %rdx, %rsi
cqto
idivq %rsi
movq %rax, %rsi
movl %esi, 0x20(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: execSql
static int execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
  sqlite3_stmt *pStmt;
  int rc;

  /* printf("SQL: [%s]\n", zSql); fflush(stdout); */
  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
  if( rc!=SQLITE_OK ) return rc;
  while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
    const char *zSubSql = (const char*)sqlite3_column_text(pStmt,0);
    assert( sqlite3_strnicmp(zSql,"SELECT",6)==0 );
    /* The secondary SQL must be one of CREATE TABLE, CREATE INDEX,
    ** or INSERT.  Historically there have been attacks that first
    ** corrupt the sqlite_schema.sql field with other kinds of statements
    ** then run VACUUM to get those statements to execute at inappropriate
    ** times. */
    if( zSubSql
     && (strncmp(zSubSql,"CRE",3)==0 || strncmp(zSubSql,"INS",3)==0)
    ){
      rc = execSql(db, pzErrMsg, zSubSql);
      if( rc!=SQLITE_OK ) break;
    }
  }
  assert( rc!=SQLITE_ROW );
  if( rc==SQLITE_DONE ) rc = SQLITE_OK;
  if( rc ){
    sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
  }
  (void)sqlite3_finalize(pStmt);
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rsp)
leaq 0x10(%rsp), %r9
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x80, %ecx
xorl %r8d, %r8d
callq 0x286af6
movl %eax, %r15d
testl %eax, %eax
jne 0x2b1353
movq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x282502
cmpl $0x64, %eax
jne 0x2b1322
movq %r15, %rdi
xorl %esi, %esi
callq 0x283756
movb $0x1, %r12b
movl $0x64, %ebp
testq %rax, %rax
je 0x2b131b
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x12f17f(%rip), %rsi    # 0x3e0463
callq 0x17330
testl %eax, %eax
je 0x2b1305
movl $0x3, %edx
movq %r13, %rdi
leaq 0x12f16b(%rip), %rsi    # 0x3e0467
callq 0x17330
testl %eax, %eax
jne 0x2b131b
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2b1268
movl %eax, %ebp
testl %eax, %eax
sete %r12b
testb %r12b, %r12b
jne 0x2b12ae
jmp 0x2b1324
movl %eax, %ebp
xorl %r15d, %r15d
cmpl $0x65, %ebp
cmovnel %ebp, %r15d
testl %r15d, %r15d
je 0x2b1349
movq %rbx, %rdi
callq 0x286451
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2aebf6
movq 0x10(%rsp), %rdi
callq 0x2817e7
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: growVTrans
static int growVTrans(sqlite3 *db){
  const int ARRAY_INCR = 5;

  /* Grow the sqlite3.aVTrans array if required */
  if( (db->nVTrans%ARRAY_INCR)==0 ){
    VTable **aVTrans;
    sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)*
                                 ((sqlite3_int64)db->nVTrans + ARRAY_INCR);
    aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
    if( !aVTrans ){
      return SQLITE_NOMEM_BKPT;
    }
    memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
    db->aVTrans = aVTrans;
  }

  return SQLITE_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x1ec(%rdi), %rax
imull $0xcccccccd, %eax, %ecx # imm = 0xCCCCCCCD
addl $0x19999999, %ecx       # imm = 0x19999999
xorl %ebx, %ebx
cmpl $0x33333332, %ecx       # imm = 0x33333332
ja 0x2b14ed
movq %rdi, %r14
leaq 0x28(,%rax,8), %rdx
movq 0x210(%rdi), %rsi
callq 0x28c4c8
testq %rax, %rax
je 0x2b14e8
movslq 0x1ec(%r14), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x20(%rax,%rcx,8)
movq %rax, 0x210(%r14)
jmp 0x2b14ed
movl $0x7, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VListNameToNum
SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
  int i, mx;
  if( pIn==0 ) return 0;
  mx = pIn[1];
  i = 2;
  do{
    const char *z = (const char*)&pIn[i+2];
    if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
    i += pIn[i+1];
  }while( i<mx );
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
testq %rdi, %rdi
je 0x2b1946
movq %rdi, %r15
movl 0x4(%rdi), %ebp
movslq %edx, %r12
movl $0x2, %ebx
movslq %ebx, %rax
leaq (%r15,%rax,4), %r14
leaq (%r15,%rax,4), %r13
addq $0x8, %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x17330
testl %eax, %eax
jne 0x2b1923
cmpb $0x0, (%r13,%r12)
je 0x2b1933
addl 0x4(%r14), %ebx
movb $0x1, %al
testb %al, %al
je 0x2b193e
cmpl %ebp, %ebx
jl 0x2b18f8
jmp 0x2b1944
movl (%r14), %eax
movl %eax, 0xc(%rsp)
xorl %eax, %eax
jmp 0x2b1929
movl 0xc(%rsp), %eax
jmp 0x2b1946
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: growOpArray
static int growOpArray(Vdbe *v, int nOp){
  VdbeOp *pNew;
  Parse *p = v->pParse;

  /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
  ** more frequent reallocs and hence provide more opportunities for
  ** simulated OOM faults.  SQLITE_TEST_REALLOC_STRESS is generally used
  ** during testing only.  With SQLITE_TEST_REALLOC_STRESS grow the op array
  ** by the minimum* amount required until the size reaches 512.  Normal
  ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
  ** size of the op array or add 1KB of space, whichever is smaller. */
#ifdef SQLITE_TEST_REALLOC_STRESS
  sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
                        : (sqlite3_int64)v->nOpAlloc+nOp);
#else
  sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
                        : (sqlite3_int64)(1024/sizeof(Op)));
  UNUSED_PARAMETER(nOp);
#endif

  /* Ensure that the size of a VDBE does not grow too large */
  if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
    sqlite3OomFault(p->db);
    return SQLITE_NOMEM;
  }

  assert( nOp<=(1024/sizeof(Op)) );
  assert( nNew>=(v->nOpAlloc+nOp) );
  pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
  if( pNew ){
    p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
    v->nOpAlloc = p->szOpAlloc/sizeof(Op);
    v->aOp = pNew;
  }
  return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x94(%rdi), %rax
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x2a, %eax
cmovneq %rcx, %rax
movq 0x18(%rdi), %r15
movq (%r15), %rdi
movslq 0x90(%rdi), %rcx
cmpq %rcx, %rax
jle 0x2b20dd
callq 0x2824bb
jmp 0x2b2152
movq 0x88(%rbx), %rsi
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
callq 0x28c4c8
testq %rax, %rax
je 0x2b2152
movq %rax, %r14
movq (%r15), %rcx
testq %rcx, %rcx
je 0x2b2121
cmpq %r14, 0x1c0(%rcx)
jbe 0x2b2121
movl $0x80, %eax
cmpq %r14, 0x1b0(%rcx)
jbe 0x2b212a
cmpq %r14, 0x1b8(%rcx)
jbe 0x2b215d
movq %r14, %rdi
callq *0x21456e(%rip)         # 0x4c6698
movl %eax, 0x3c(%r15)
cltq
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
movl %edx, 0x94(%rbx)
movq %r14, 0x88(%rbx)
xorl %eax, %eax
jmp 0x2b2157
movl $0x7, %eax
popq %rbx
popq %r14
popq %r15
retq
movzwl 0x176(%rcx), %eax
jmp 0x2b212a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeChangeP4Full
static void SQLITE_NOINLINE vdbeChangeP4Full(
  Vdbe *p,
  Op *pOp,
  const char *zP4,
  int n
){
  if( pOp->p4type ){
    freeP4(p->db, pOp->p4type, pOp->p4.p);
    pOp->p4type = 0;
    pOp->p4.p = 0;
  }
  if( n<0 ){
    sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);
  }else{
    if( n==0 ) n = sqlite3Strlen30(zP4);
    pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
    pOp->p4type = P4_DYNAMIC;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsbl 0x1(%rsi), %esi
testl %esi, %esi
je 0x2b219a
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
callq 0x29991d
movb $0x0, 0x1(%rbx)
movq $0x0, 0x10(%rbx)
testl %r12d, %r12d
js 0x2b21ba
jne 0x2b21e7
testq %r14, %r14
je 0x2b21e4
movq %r14, %rdi
callq 0x172f0
movq %rax, %r12
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
jmp 0x2b21e7
subq 0x88(%r15), %rbx
shrq $0x3, %rbx
imull $0xaaaaaaab, %ebx, %esi # imm = 0xAAAAAAAB
movq %r15, %rdi
movq %r14, %rdx
movl %r12d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x285198
xorl %r12d, %r12d
movl %r12d, %r12d
testq %r14, %r14
je 0x2b2201
movq (%r15), %rdi
leaq 0x1(%r12), %rsi
callq 0x28c518
movq %rax, %r15
jmp 0x2b2204
xorl %r15d, %r15d
testq %r15, %r15
je 0x2b221c
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x17660
movb $0x0, (%r15,%r12)
movq %r15, 0x10(%rbx)
movb $-0x7, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeSetNumCols
SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
  int n;
  sqlite3 *db = p->db;

  if( p->nResColumn ){
    releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
    sqlite3DbFree(db, p->aColName);
  }
  n = nResColumn*COLNAME_N;
  p->nResColumn = (u16)nResColumn;
  p->aColName = (Mem*)sqlite3DbMallocRawNN(db, sizeof(Mem)*n );
  if( p->aColName==0 ) return;
  initMemArray(p->aColName, n, db, MEM_Null);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
movq (%rdi), %rbx
movzwl 0xc0(%rdi), %esi
testl %esi, %esi
je 0x2b2390
movq 0x98(%r15), %rdi
addl %esi, %esi
callq 0x29983d
movq 0x98(%r15), %rsi
testq %rsi, %rsi
je 0x2b2390
movq %rbx, %rdi
callq 0x28c3e7
leal (%r14,%r14), %ebp
movw %r14w, 0xc0(%r15)
movslq %ebp, %rax
imulq $0x38, %rax, %rsi
movq %rbx, %rdi
callq 0x28c518
movq %rax, 0x98(%r15)
testq %rax, %rax
sete %cl
testl %r14d, %r14d
setle %dl
orb %cl, %dl
jne 0x2b23e3
addq $0x28, %rax
incl %ebp
movq %rbx, (%rax)
movw $0x1, -0x20(%rax)
movl $0x0, -0x8(%rax)
addq $0x38, %rax
decl %ebp
cmpl $0x1, %ebp
jg 0x2b23c8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: accessPayloadChecked
static SQLITE_NOINLINE int accessPayloadChecked(
  BtCursor *pCur,
  u32 offset,
  u32 amt,
  void *pBuf
){
  int rc;
  if ( pCur->eState==CURSOR_INVALID ){
    return SQLITE_ABORT;
  }
  assert( cursorOwnsBtShared(pCur) );
  rc = btreeRestoreCursorPosition(pCur);
  return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x4, %eax
cmpb $0x1, (%rdi)
je 0x2b2413
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0x2a87bf
testl %eax, %eax
je 0x2b241e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x297e3f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ReadSchema
SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){
  int rc = SQLITE_OK;
  sqlite3 *db = pParse->db;
  assert( sqlite3_mutex_held(db->mutex) );
  if( !db->init.busy ){
    rc = sqlite3Init(db, &pParse->zErrMsg);
    if( rc!=SQLITE_OK ){
      pParse->rc = rc;
      pParse->nErr++;
    }else if( db->noSharedCache ){
      db->mDbFlags |= DBFLAG_SchemaKnownOk;
    }
  }
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r14
xorl %ebx, %ebx
cmpb $0x0, 0xb5(%r14)
jne 0x2b247a
movq %rdi, %r15
leaq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x28acc3
testl %eax, %eax
je 0x2b246e
movl %eax, 0x18(%r15)
incl 0x30(%r15)
movl %eax, %ebx
jmp 0x2b247a
cmpb $0x0, 0x69(%r14)
je 0x2b247a
orb $0x10, 0x2c(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PragmaVtabRegister
SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3 *db, const char *zName){
  const PragmaName *pName;
  assert( sqlite3_strnicmp(zName, "pragma_", 7)==0 );
  pName = pragmaLocate(zName+7);
  if( pName==0 ) return 0;
  if( (pName->mPragFlg & (PragFlg_Result0|PragFlg_Result1))==0 ) return 0;
  assert( sqlite3HashFind(&db->aModule, zName)==0 );
  return sqlite3VtabCreateModule(db, zName, &pragmaVtabModule, (void*)pName, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7(%rsi), %rdi
callq 0x2b24c9
testq %rax, %rax
je 0x2b24bf
testb $0x30, 0x9(%rax)
je 0x2b24bf
leaq 0x20f749(%rip), %rdx    # 0x4c1bf0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b2587
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaLocate
static const PragmaName *pragmaLocate(const char *zName){
  int upr, lwr, mid = 0, rc;
  lwr = 0;
  upr = ArraySize(aPragmaName)-1;
  while( lwr<=upr ){
    mid = (lwr+upr)/2;
    rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
    if( rc==0 ) break;
    if( rc<0 ){
      upr = mid - 1;
    }else{
      lwr = mid + 1;
    }
  }
  return lwr>upr ? 0 : &aPragmaName[mid];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %esi, %esi
movl $0x40, %ecx
leaq 0x20f7d3(%rip), %rax    # 0x4c1cb0
leaq 0x12857c(%rip), %rdx    # 0x3daa60
xorl %r8d, %r8d
leal (%rcx,%r8), %r10d
movl %r10d, %r9d
shrl $0x1f, %r9d
addl %r10d, %r9d
sarl %r9d
movslq %r9d, %r10
leaq (%r10,%r10,2), %r10
movq (%rax,%r10,8), %r11
testq %rdi, %rdi
je 0x2b2539
testq %r11, %r11
je 0x2b2545
xorl %ebx, %ebx
movzbl (%rdi,%rbx), %r14d
movzbl (%r11,%rbx), %r15d
cmpb %r15b, %r14b
jne 0x2b2525
testq %r14, %r14
jne 0x2b2534
jmp 0x2b254c
movzbl (%r14,%rdx), %ebp
movzbl (%r15,%rdx), %r14d
subl %r14d, %ebp
jne 0x2b254e
incq %rbx
jmp 0x2b250f
negq %r11
movl $0x0, %ebp
sbbl %ebp, %ebp
jmp 0x2b254e
movl $0x1, %ebp
jmp 0x2b254e
xorl %ebp, %ebp
testl %ebp, %ebp
je 0x2b2572
leal -0x1(%r9), %esi
incl %r9d
testl %ebp, %ebp
cmovsl %r8d, %r9d
cmovsl %esi, %ecx
movl %r9d, %r8d
cmpl %ecx, %r9d
setg %sil
jle 0x2b24e7
leaq (%rax,%r10,8), %rcx
xorl %eax, %eax
testb $0x1, %sil
cmoveq %rcx, %rax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VtabCreateModule
SQLITE_PRIVATE Module *sqlite3VtabCreateModule(
  sqlite3 *db,                    /* Database in which module is registered */
  const char *zName,              /* Name assigned to this module */
  const sqlite3_module *pModule,  /* The definition of the module */
  void *pAux,                     /* Context pointer for xCreate/xConnect */
  void (*xDestroy)(void *)        /* Module destructor function */
){
  Module *pMod;
  Module *pDel;
  char *zCopy;
  if( pModule==0 ){
    zCopy = (char*)zName;
    pMod = 0;
  }else{
    int nName = sqlite3Strlen30(zName);
    pMod = (Module *)sqlite3Malloc(sizeof(Module) + nName + 1);
    if( pMod==0 ){
      sqlite3OomFault(db);
      return 0;
    }
    zCopy = (char *)(&pMod[1]);
    memcpy(zCopy, zName, nName+1);
    pMod->zName = zCopy;
    pMod->pModule = pModule;
    pMod->pAux = pAux;
    pMod->xDestroy = xDestroy;
    pMod->pEpoTab = 0;
    pMod->nRefModule = 1;
  }
  pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
  if( pDel ){
    if( pDel==pMod ){
      sqlite3OomFault(db);
      sqlite3DbFree(db, pDel);
      pMod = 0;
    }else{
      sqlite3VtabEponymousTableClear(db, pDel);
      sqlite3VtabModuleUnref(db, pDel);
    }
  }
  return pMod;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x2b261f
movq %r8, %r13
movq %rdx, %rbp
movq %rcx, 0x10(%rsp)
testq %r15, %r15
je 0x2b25c5
movq %r15, %rdi
callq 0x172f0
movq %rax, %r12
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
leal 0x31(%r12), %edi
callq 0x27c381
movq %rax, %r14
testq %rax, %rax
je 0x2b2624
movq %r13, 0x8(%rsp)
leaq 0x30(%r14), %r13
incl %r12d
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x17660
movq %r13, 0x8(%r14)
movq %rbp, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r14)
movq $0x0, 0x28(%r14)
movl $0x1, 0x10(%r14)
movq %r13, %r15
jmp 0x2b262c
xorl %r14d, %r14d
jmp 0x2b2631
movq %rbx, %rdi
callq 0x2824bb
testq %r14, %r14
je 0x2b268d
leaq 0x1f0(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2aed98
testq %rax, %rax
je 0x2b2690
movq %rax, %r15
cmpq %r14, %rax
je 0x2b267a
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x2b266d
orb $0x2, 0x40(%rsi)
movq %rbx, %rdi
callq 0x27bd74
movq $0x0, 0x28(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x299a37
jmp 0x2b2690
movq %rbx, %rdi
callq 0x2824bb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x28c3e7
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq