LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: findElementWithHash
static HashElem *findElementWithHash(
  const Hash *pH,     /* The pH to be searched */
  const char *pKey,   /* The key we are searching for */
  unsigned int *pHash /* Write the hash value here */
){
  HashElem *elem;                /* Used to loop thru the element list */
  unsigned int count;            /* Number of elements left to test */
  unsigned int h;                /* The computed hash */
  static HashElem nullElement = { 0, 0, 0, 0 };

  if( pH->ht ){   /*OPTIMIZATION-IF-TRUE*/
    struct _ht *pEntry;
    h = strHash(pKey) % pH->htsize;
    pEntry = &pH->ht[h];
    elem = pEntry->chain;
    count = pEntry->count;
  }else{
    h = 0;
    elem = pH->first;
    count = pH->count;
  }
  if( pHash ) *pHash = h;
  while( count-- ){
    assert( elem!=0 );
    if( sqlite3StrICmp(elem->pKey,pKey)==0 ){
      return elem;
    }
    elem = elem->next;
  }
  return &nullElement;
}

// Assembly:
movq %rdx, %rcx
movq 0x10(%rdi), %r8
testq %r8, %r8
je 0x2a54bf
movb (%rsi), %r10b
testb %r10b, %r10b
je 0x2a54c7
leaq 0x1(%rsi), %rdx
xorl %eax, %eax
leaq 0x12be41(%rip), %r9     # 0x3d12e0
movzbl %r10b, %r10d
movzbl (%r10,%r9), %r10d
addl %eax, %r10d
imull $0x9e3779b1, %r10d, %eax # imm = 0x9E3779B1
movb (%rdx), %r10b
incq %rdx
testb %r10b, %r10b
jne 0x2a549f
jmp 0x2a54c9
leaq 0x4(%rdi), %r8
xorl %edx, %edx
jmp 0x2a54da
xorl %eax, %eax
xorl %edx, %edx
divl (%rdi)
movq %rdx, %rax
shlq $0x4, %rax
addq %rax, %r8
movq %r8, %rdi
movl (%r8), %r8d
movq 0x8(%rdi), %rdi
testq %rcx, %rcx
je 0x2a54e8
movl %edx, (%rcx)
leaq 0x219979(%rip), %rax    # 0x4bee68
testl %r8d, %r8d
je 0x2a5532
leaq 0x12bde5(%rip), %rcx    # 0x3d12e0
decl %r8d
movq 0x18(%rdi), %rdx
xorl %r9d, %r9d
movzbl (%rdx,%r9), %r10d
movzbl (%rsi,%r9), %r11d
cmpb %r11b, %r10b
jne 0x2a551b
testq %r10, %r10
jne 0x2a5525
jmp 0x2a5533
movb (%r10,%rcx), %r10b
cmpb (%r11,%rcx), %r10b
jne 0x2a552a
incq %r9
jmp 0x2a5505
movq (%rdi), %rdi
testl %r8d, %r8d
jne 0x2a54fb
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: corruptSchema
static void corruptSchema(
  InitData *pData,     /* Initialization context */
  const char *zObj,    /* Object being parsed at the point of error */
  const char *zExtra   /* Error information */
){
  sqlite3 *db = pData->db;
  if( db->mallocFailed ){
    pData->rc = SQLITE_NOMEM_BKPT;
  }else if( pData->pzErrMsg[0]!=0 ){
    /* A error message has already been generated.  Do not overwrite it */
  }else if( pData->mInitFlags & INITFLAG_AlterTable ){
    *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra);
    pData->rc = SQLITE_ERROR;
  }else if( db->flags & SQLITE_WriteSchema ){
    pData->rc = SQLITE_CORRUPT_BKPT;
  }else{
    char *z;
    if( zObj==0 ) zObj = "?";
    z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
    if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
    *pData->pzErrMsg = z;
    pData->rc = SQLITE_CORRUPT_BKPT;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movl $0x7, %ebp
cmpb $0x0, 0x61(%r15)
je 0x2a55bd
movl %ebp, 0x14(%rbx)
jmp 0x2a55c7
movq 0x8(%rbx), %rax
cmpq $0x0, (%rax)
je 0x2a55d2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
testb $0x1, 0x18(%rbx)
jne 0x2a5654
testb $0x1, 0x30(%r15)
jne 0x2a5670
testq %rsi, %rsi
leaq 0xd154d(%rip), %rdx     # 0x376b3d
cmovneq %rsi, %rdx
leaq 0x131118(%rip), %rsi    # 0x3d6713
movq %r15, %rdi
xorl %eax, %eax
callq 0x27b56a
testq %r14, %r14
je 0x2a5627
cmpb $0x0, (%r14)
je 0x2a5627
leaq 0x13111b(%rip), %rsi    # 0x3d6732
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x27b56a
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
leaq 0x130596(%rip), %rsi    # 0x3d5bcb
leaq 0x1306a0(%rip), %rdx    # 0x3d5cdc
leaq 0x1303ee(%rip), %r8     # 0x3d5a31
movl $0xb, %ebp
movl $0xb, %edi
movl $0x1f57e, %ecx          # imm = 0x1F57E
jmp 0x2a5694
movq %r15, %rdi
movq %r14, %rsi
callq 0x279928
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movl $0x1, %ebp
jmp 0x2a55b8
leaq 0x130554(%rip), %rsi    # 0x3d5bcb
leaq 0x13065e(%rip), %rdx    # 0x3d5cdc
leaq 0x1303ac(%rip), %r8     # 0x3d5a31
movl $0xb, %ebp
movl $0xb, %edi
movl $0x1f577, %ecx          # imm = 0x1F577
xorl %eax, %eax
callq 0x274d08
jmp 0x2a55b8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3GetUInt32
SQLITE_PRIVATE int sqlite3GetUInt32(const char *z, u32 *pI){
  u64 v = 0;
  int i;
  for(i=0; sqlite3Isdigit(z[i]); i++){
    v = v*10 + z[i] - '0';
    if( v>4294967296LL ){ *pI = 0; return 0; }
  }
  if( i==0 || z[i]!=0 ){ *pI = 0; return 0; }
  *pI = (u32)v;
  return 1;
}

// Assembly:
movzbl (%rdi), %r8d
leaq -0x30(%r8), %rdx
xorl %ecx, %ecx
movl $0x0, %eax
cmpq $0x9, %rdx
ja 0x2a570d
incq %rdi
xorl %ecx, %ecx
movabsq $0x100000000, %r9       # imm = 0x100000000
xorl %eax, %eax
leaq (%rax,%rax,4), %rax
movsbq %r8b, %r8
leaq (%r8,%rax,2), %rax
addq $-0x30, %rax
cmpq %r9, %rax
ja 0x2a570b
movzbl (%rdi), %r8d
movq %r8, %r10
addq $-0x3a, %r10
incq %rdi
cmpq $-0xb, %r10
ja 0x2a56c6
cmpq $0xa, %rdx
setb %dl
testb %r8b, %r8b
sete %dil
xorl %ecx, %ecx
andb %dl, %dil
cmovnel %eax, %ecx
movzbl %dil, %eax
jmp 0x2a570d
xorl %eax, %eax
movl %ecx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movl 0x28(%rdi), %ebp
testl %ebp, %ebp
jle 0x2a5b99
movq %rdx, %rbx
movq %rsi, %r14
movq 0x20(%rdi), %r15
xorl %r13d, %r13d
xorl %esi, %esi
cmpl $0x2, %r13d
setb %sil
xorl %r13d, %esi
movq %rsi, %rax
shlq $0x5, %rax
movq 0x18(%r15,%rax), %r12
testq %rbx, %rbx
je 0x2a5b77
movq %r15, %rdi
movq %rbx, %rdx
callq 0x2a5bfa
testl %eax, %eax
je 0x2a5b91
addq $0x20, %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2a547e
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x2a5b9b
incl %r13d
cmpl %r13d, %ebp
jne 0x2a5b4a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a5dee
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 0x12c0eb(%rip), %rsi    # 0x3d1efa
callq 0x17660
movzwl 0x5e(%rbx), %eax
cmpw %ax, %r15w
jae 0x2a5e41
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 0x2a5e2d
cmpb $0x0, 0x62(%rbx)
je 0x2a5e51
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_O3/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), %eax
cmpl $0x2d, %eax
jne 0x2a5fd9
incq %rdi
movq $-0x1, %rcx
jmp 0x2a600b
cmpl $0x30, %eax
je 0x2a5fec
cmpl $0x2b, %eax
jne 0x2a606c
incq %rdi
jmp 0x2a6009
movzbl 0x1(%rdi), %ecx
orl $0x20, %ecx
cmpl $0x78, %ecx
jne 0x2a6009
movzbl 0x2(%rdi), %edx
leaq 0x12b43d(%rip), %rcx    # 0x3d1440
testb $0x8, (%rdx,%rcx)
jne 0x2a6087
xorl %ecx, %ecx
movb (%rdi), %dl
movzbl %dl, %r8d
addq $-0x3a, %r8
cmpq $-0xa, %r8
jb 0x2a6069
cmpb $0x30, %dl
jne 0x2a602f
leaq 0x1(%rdi), %rdx
cmpb $0x30, 0x1(%rdi)
movq %rdx, %rdi
je 0x2a6020
jmp 0x2a6032
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %edi, %edi
movzbl (%rdx,%r8), %r9d
leal -0x30(%r9), %r10d
cmpb $0x9, %r10b
ja 0x2a605d
leaq (%rdi,%rdi,4), %rdi
andl $0xf, %r9d
leaq (%r9,%rdi,2), %rdi
incq %r8
cmpq $0xb, %r8
jne 0x2a6037
jmp 0x2a6069
addq %rdi, %rcx
cmpq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
jle 0x2a6072
xorl %eax, %eax
retq
xorl %ecx, %ecx
movl %eax, %edx
jmp 0x2a600d
movl %edi, %r8d
negl %r8d
cmpb $0x2d, %al
cmovnel %edi, %r8d
movl %r8d, (%rsi)
movl $0x1, %eax
retq
addq $0x2, %rdi
movzbl (%rdi), %edx
incq %rdi
cmpq $0x30, %rdx
je 0x2a608b
movb $0x1, %r9b
xorl %eax, %eax
testb $0x8, (%rdx,%rcx)
movl $0x0, %r8d
je 0x2a60f2
xorl %r9d, %r9d
xorl %r8d, %r8d
movl %r8d, %r10d
shll $0x4, %r10d
leal (%rdx,%rdx), %r8d
sarb $0x7, %r8b
andb $0x9, %r8b
addb %dl, %r8b
andb $0xf, %r8b
movzbl %r8b, %r8d
orl %r10d, %r8d
movzbl (%rdi,%r9), %edx
movb (%rdx,%rcx), %r10b
cmpq $0x6, %r9
ja 0x2a60ea
incq %r9
movl %r10d, %r11d
andb $0x8, %r11b
jne 0x2a60ae
testb $0x8, %r10b
sete %r9b
testl %r8d, %r8d
js 0x2a6086
testb %r9b, %r9b
jne 0x2a607e
jmp 0x2a6086
// File: /workspace/github_c_makefile_star2_O3/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 0x2a6119
movq %r14, %rdi
callq 0x2a6164
movq 0x50(%rbx), %rsi
testq %rsi, %rsi
je 0x2a612a
movq %r14, %rdi
callq 0x2a65a3
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x2a613b
movq %r14, %rdi
callq 0x282904
testb $0x10, 0x63(%rbx)
je 0x2a6152
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x2a6152
movq %r14, %rdi
callq 0x282904
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x282904
// File: /workspace/github_c_makefile_star2_O3/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 0x2a61a0
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2a618f
cmpb $-0x51, (%rbx)
je 0x2a618f
movq %r14, %rdi
callq 0x2a6164
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2a61dd
movq %r14, %rdi
callq 0x2a6164
movl 0x4(%rbx), %eax
btl $0x10, %eax
jae 0x2a61bd
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2a61bd
movq %r14, %rdi
callq 0x282904
movl 0x4(%rbx), %eax
btl $0x1b, %eax
jb 0x2a61d5
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x282904
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x4(%rbx), %eax
btl $0xb, %eax
movq 0x20(%rbx), %rsi
jb 0x2a620e
testq %rsi, %rsi
je 0x2a61fa
movq %r14, %rdi
callq 0x2a65a3
movl 0x4(%rbx), %eax
btl $0x18, %eax
jae 0x2a61a0
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2a6225
jmp 0x2a61a0
testq %rsi, %rsi
je 0x2a61a0
movq %r14, %rdi
movl $0x1, %edx
callq 0x2a62e6
jmp 0x2a61a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2a62e5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rcx
testq %rcx, %rcx
je 0x2a625d
movq 0x40(%rbx), %rax
movq %rax, (%rcx)
testq %rax, %rax
je 0x2a6255
movq 0x38(%rbx), %rcx
movq %rcx, 0x38(%rax)
movq $0x0, 0x38(%rbx)
movq 0x48(%rbx), %rsi
testq %rsi, %rsi
je 0x2a626e
movq %r14, %rdi
callq 0x2a6164
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2a627f
movq %r14, %rdi
callq 0x2a65a3
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2a6290
movq %r14, %rdi
callq 0x2a65a3
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x2a62a1
movq %r14, %rdi
callq 0x2a6164
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x2a62b2
movq %r14, %rdi
callq 0x2a6164
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x2a62c2
movq %r14, %rdi
callq 0x282904
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2a62d3
movq %r14, %rdi
callq 0x282904
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x282904
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a63ce
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 0x2a6318
movq %rbx, %rdi
callq 0x2a65a3
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x2a63cf
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x2a6335
movq %rbx, %rdi
callq 0x2a6164
movq 0x38(%r14), %rsi
testq %rsi, %rsi
je 0x2a6346
movq %rbx, %rdi
callq 0x2a65a3
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x2a6357
movq %rbx, %rdi
callq 0x2a6164
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x2a6368
movq %rbx, %rdi
callq 0x2a65a3
movq 0x60(%r14), %rsi
testq %rsi, %rsi
je 0x2a6379
movq %rbx, %rdi
callq 0x2a6164
movq 0x78(%r14), %rsi
testq %rsi, %rsi
je 0x2a6396
movq 0x40(%rsi), %r12
movq %rbx, %rdi
callq 0x2a6225
movq %r12, %rsi
testq %r12, %r12
jne 0x2a6382
movq 0x68(%r14), %rsi
testq %rsi, %rsi
je 0x2a63a7
movq %rbx, %rdi
callq 0x2a64ba
testb $0x1, %bpl
jne 0x2a63b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x282904
xorl %ebp, %ebp
movq %r15, %r14
testq %r15, %r15
jne 0x2a6303
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a64b9
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rsi)
jle 0x2a64a4
leaq 0x68(%rbx), %r15
xorl %ebp, %ebp
movq -0x58(%r15), %rsi
testq %rsi, %rsi
je 0x2a6405
movq %r14, %rdi
callq 0x282904
movq -0x50(%r15), %rsi
testq %rsi, %rsi
je 0x2a6416
movq %r14, %rdi
callq 0x282904
movq -0x48(%r15), %rsi
testq %rsi, %rsi
je 0x2a6427
movq %r14, %rdi
callq 0x282904
movb -0x23(%r15), %al
testb $0x2, %al
je 0x2a6443
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2a6443
movq %r14, %rdi
callq 0x282904
movb -0x23(%r15), %al
testb $0x4, %al
je 0x2a6457
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2a6457
movq %r14, %rdi
callq 0x2a65a3
movq -0x40(%r15), %rsi
movq %r14, %rdi
callq 0x272447
movq -0x38(%r15), %rsi
testq %rsi, %rsi
je 0x2a6479
movq %r14, %rdi
movl $0x1, %edx
callq 0x2a62e6
movq -0x18(%r15), %rsi
testq %rsi, %rsi
je 0x2a648a
movq %r14, %rdi
callq 0x2a6164
movq -0x10(%r15), %rsi
movq %r14, %rdi
callq 0x2a6536
incl %ebp
addq $0x70, %r15
cmpl (%rbx), %ebp
jl 0x2a63f4
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x282904
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a6535
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rsi)
jle 0x2a651f
leaq 0x20(%rbx), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x2a64ea
movq %r14, %rdi
callq 0x2a65a3
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2a64ff
movq %r14, %rdi
movl $0x1, %edx
callq 0x2a62e6
movq -0x10(%r15), %rsi
testq %rsi, %rsi
je 0x2a6510
movq %r14, %rdi
callq 0x282904
incq %r12
movslq (%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x2a64d9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x282904
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a65c8
movq %r14, %rdi
callq 0x2a6164
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x2a65d9
movq %r14, %rdi
callq 0x282904
addq $0x18, %r15
decl %ebp
cmpl $0x1, %ebp
jg 0x2a65b8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x282904
// File: /workspace/github_c_makefile_star2_O3/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 0x2a6862
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 0x2a6909
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
movl 0x50(%rdi), %eax
testq %rax, %rax
je 0x2a68d5
leal 0x1(%rax), %ecx
cmpl 0x48(%rbx), %ecx
jae 0x2a68c1
movl %ecx, 0x50(%rbx)
movq 0x40(%rbx), %rcx
movb $0xa, (%rcx,%rax)
jmp 0x2a68d5
leaq 0x1197d7(%rip), %rsi    # 0x3c009f
movq %r15, %rdi
movl $0x1, %edx
callq 0x274968
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x2a68ee
movl 0x30(%rbx), %edx
movl 0x34(%rbx), %ecx
movq %r15, %rdi
xorl %eax, %eax
callq 0x274dfa
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x272d87
cmpb $0x7, 0x54(%rbx)
jne 0x2a6909
movl $0x1, 0x24(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x28e6a5
testl %eax, %eax
je 0x2a6972
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x2a694c
cmpl $0x7, %eax
jne 0x2a6954
movl $0x1, 0x24(%r14)
leaq 0x12ffa2(%rip), %rsi    # 0x3d68fd
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2a6807
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 0x2a6967
movzbl %r15b, %ecx
movl %eax, (%rsp)
leaq 0x12ff81(%rip), %rsi    # 0x3d691a
movq %r14, %rdi
movl %ebx, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x2a6807
jmp 0x2a6967
// File: /workspace/github_c_makefile_star2_O3/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 0x2a71f6
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 0x2a720d
leaq 0x12f6f7(%rip), %rsi    # 0x3d68e4
xorl %eax, %eax
callq 0x2a6807
jmp 0x2a7209
leaq 0x12f6d0(%rip), %rsi    # 0x3d68cd
xorl %eax, %eax
callq 0x2a6807
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
movq 0x60(%rdi), %rcx
movl 0x168(%rcx), %ecx
testl %ecx, %ecx
jne 0x2a7209
orb %r8b, %r9b
movb %r9b, (%rax,%rsi)
xorl %ebx, %ebx
jmp 0x2a7209
// File: /workspace/github_c_makefile_star2_O3/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 0x2a725f
movq (%rsi), %r14
movq 0x8(%rbx), %rdi
callq 0x282904
movq %r14, %rsi
testq %r14, %r14
jne 0x2a724b
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_O3/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
movzwl 0x30(%rdi), %ecx
testw %cx, %cx
je 0x2a7293
movq 0x20(%rbx), %rax
decl %ecx
jmp 0x2a72b7
movq 0x8(%rbx), %rdi
movl $0x3f8, %esi            # imm = 0x3F8
callq 0x282a35
testq %rax, %rax
je 0x2a72c5
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
addq $0x8, %rax
movw $0x29, %cx
movw %cx, 0x30(%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x20(%rbx)
popq %rbx
retq
xorl %eax, %eax
jmp 0x2a72c3
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdi, %r15
leaq 0x20(%rsp), %r14
xorl %ebx, %ebx
movl $0x140, %edx            # imm = 0x140
movq %r14, %rdi
xorl %esi, %esi
callq 0x173a0
testq %r15, %r15
je 0x2a738c
xorl %ebx, %ebx
leaq 0x8(%rsp), %rax
movq 0x8(%r15), %rcx
movq $0x0, 0x8(%r15)
testq %rbx, %rbx
je 0x2a7375
xorl %edx, %edx
movq %r14, %rsi
movq %rax, %rdi
movq (%rbx), %r8
movq %r15, %r9
movq %r9, %r15
cmpq (%r9), %r8
jle 0x2a7337
movq %r15, 0x8(%rdi)
movq 0x8(%r15), %r9
movq %r15, %rdi
testq %r9, %r9
jne 0x2a731d
jmp 0x2a734b
jge 0x2a7340
movq %rbx, 0x8(%rdi)
movq %rbx, %rdi
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2a7317
jmp 0x2a7351
movq %r15, %rdi
movq %rbx, %r15
movq %r15, 0x8(%rdi)
movq 0x10(%rsp), %r15
movq $0x0, (%rsi)
incl %edx
leaq (%rsp,%rdx,8), %rsi
addq $0x20, %rsi
movq (%rsi), %rbx
testq %rbx, %rbx
jne 0x2a7314
jmp 0x2a7378
movq %r14, %rsi
movq %r15, (%rsi)
movq 0x20(%rsp), %rbx
movq %rcx, %r15
testq %rcx, %rcx
jne 0x2a72fe
movl $0x1, %eax
leaq 0x8(%rsp), %rcx
movq 0x20(%rsp,%rax,8), %rdx
testq %rdx, %rdx
je 0x2a73f0
testq %rbx, %rbx
je 0x2a73ed
movq %rcx, %rsi
movq (%rbx), %rdi
movq %rdx, %r8
movq %r8, %rdx
cmpq (%r8), %rdi
jle 0x2a73c8
movq %rdx, 0x8(%rsi)
movq 0x8(%rdx), %r8
movq %rdx, %rsi
testq %r8, %r8
jne 0x2a73ae
jmp 0x2a73dc
jge 0x2a73d1
movq %rbx, 0x8(%rsi)
movq %rbx, %rsi
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2a73a8
jmp 0x2a73e2
movq %rdx, %rsi
movq %rbx, %rdx
movq %rdx, 0x8(%rsi)
movq 0x10(%rsp), %rbx
jmp 0x2a73f0
movq %rdx, %rbx
incq %rax
cmpq $0x28, %rax
jne 0x2a7396
movq %rbx, %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a74fd
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x2, %esi
jl 0x2a7501
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x2a74b8
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2a7511
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x2a74b8
movq %rax, 0x8(%rbx)
jmp 0x2a7514
xorl %ebx, %ebx
jmp 0x2a7514
movq 0x8(%rbx), %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x2a7514
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a757b
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 0x284ab7
testq %rax, %rax
je 0x2a75cb
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2a76b3
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x282904
jmp 0x2a75d0
movl $0x7, %ebp
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %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 0x27d0b1
movl %eax, %ebp
testl %eax, %eax
jne 0x2a7784
movq 0x10(%rsp), %rdi
callq 0x278b63
cmpl $0x64, %eax
jne 0x2a7758
movq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x279d14
testq %rax, %rax
je 0x2a774b
movzbl (%rax), %ecx
cmpl $0x49, %ecx
je 0x2a772d
cmpl $0x43, %ecx
jne 0x2a774b
cmpb $0x52, 0x1(%rax)
jne 0x2a774b
cmpb $0x45, 0x2(%rax)
je 0x2a7739
jmp 0x2a774b
cmpb $0x4e, 0x1(%rax)
jne 0x2a774b
cmpb $0x53, 0x2(%rax)
jne 0x2a774b
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2a76b3
testl %eax, %eax
jne 0x2a7758
movq %r15, %rdi
callq 0x278b63
cmpl $0x64, %eax
je 0x2a7703
xorl %ebp, %ebp
cmpl $0x65, %eax
cmovnel %eax, %ebp
testl %ebp, %ebp
je 0x2a777a
movq %rbx, %rdi
callq 0x27c968
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2a5071
movq 0x10(%rsp), %rdi
callq 0x277e46
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a78d5
movq %rdi, %r14
leaq 0x28(,%rax,8), %rdx
movq 0x210(%rdi), %rsi
callq 0x2829e5
testq %rax, %rax
je 0x2a78d0
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 0x2a78d5
movl $0x7, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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
pushq %rax
movq %rsi, (%rsp)
xorl %eax, %eax
testq %rdi, %rdi
je 0x2a7d2e
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 (%rsp), %rsi
movq %r12, %rdx
callq 0x17330
testl %eax, %eax
jne 0x2a7d1f
cmpb $0x0, (%r13,%r12)
je 0x2a7d2b
addl 0x4(%r14), %ebx
cmpl %ebp, %ebx
jl 0x2a7cf5
xorl %eax, %eax
jmp 0x2a7d2e
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a84b2
callq 0x278b1c
jmp 0x2a8527
movq 0x88(%rbx), %rsi
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
callq 0x2829e5
testq %rax, %rax
je 0x2a8527
movq %rax, %r14
movq (%r15), %rcx
testq %rcx, %rcx
je 0x2a84f6
cmpq %r14, 0x1c0(%rcx)
jbe 0x2a84f6
movl $0x80, %eax
cmpq %r14, 0x1b0(%rcx)
jbe 0x2a84ff
cmpq %r14, 0x1b8(%rcx)
jbe 0x2a8532
movq %r14, %rdi
callq *0x213199(%rip)         # 0x4bb698
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 0x2a852c
movl $0x7, %eax
popq %rbx
popq %r14
popq %r15
retq
movzwl 0x176(%rcx), %eax
jmp 0x2a84ff
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsbl 0x1(%rsi), %esi
testl %esi, %esi
je 0x2a856e
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
callq 0x28fb69
movb $0x0, 0x1(%rbx)
movq $0x0, 0x10(%rbx)
testl %ebp, %ebp
js 0x2a857e
je 0x2a85a4
testq %r14, %r14
je 0x2a85e5
movl %ebp, %r12d
jmp 0x2a85bb
subq 0x88(%r15), %rbx
shrq $0x3, %rbx
imull $0xaaaaaaab, %ebx, %esi # imm = 0xAAAAAAAB
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27b778
testq %r14, %r14
je 0x2a85e5
movq %r14, %rdi
callq 0x172f0
movq %rax, %r12
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
movq (%r15), %rdi
leaq 0x1(%r12), %rsi
callq 0x282a35
testq %rax, %rax
je 0x2a85e5
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x17660
movb $0x0, (%r15,%r12)
jmp 0x2a85e8
xorl %r15d, %r15d
movq %r15, 0x10(%rbx)
movb $-0x7, 0x1(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a8759
movq 0x98(%r15), %rdi
addl %esi, %esi
callq 0x28fa89
movq 0x98(%r15), %rsi
testq %rsi, %rsi
je 0x2a8759
movq %rbx, %rdi
callq 0x282904
leal (%r14,%r14), %ebp
movw %r14w, 0xc0(%r15)
movslq %ebp, %rax
imulq $0x38, %rax, %rsi
movq %rbx, %rdi
callq 0x282a35
movq %rax, 0x98(%r15)
testq %rax, %rax
sete %cl
testl %r14d, %r14d
setle %dl
orb %cl, %dl
jne 0x2a87ac
addq $0x28, %rax
incl %ebp
movq %rbx, (%rax)
movw $0x1, -0x20(%rax)
movl $0x0, -0x8(%rax)
addq $0x38, %rax
decl %ebp
cmpl $0x1, %ebp
ja 0x2a8791
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a87dc
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0x29ef8c
testl %eax, %eax
je 0x2a87e7
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 0x28e1f6
// File: /workspace/github_c_makefile_star2_O3/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 0x2a8843
movq %rdi, %r15
leaq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x281162
testl %eax, %eax
je 0x2a8837
movl %eax, 0x18(%r15)
incl 0x30(%r15)
movl %eax, %ebx
jmp 0x2a8843
cmpb $0x0, 0x69(%r14)
je 0x2a8843
orb $0x10, 0x2c(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2a8892
testq %rax, %rax
je 0x2a8888
testb $0x30, 0x9(%rax)
je 0x2a8888
leaq 0x20e370(%rip), %rdx    # 0x4b6be0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a8938
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq