LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x24b770
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x24b9d8
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x24b639
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x24b63f
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x24b63f
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x24b639
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x24b639
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x21f26b
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x21f26b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d0fc
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
sete %bpl
testq %r14, %r14
je 0x24b82b
movq %r14, %r15
movq 0x20(%r14), %rsi
movq 0x50(%r14), %r14
movq %rbx, %rdi
callq 0x24b63f
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x24b836
movq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x24b639
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x24b63f
movq 0x40(%r15), %rsi
movq %rbx, %rdi
callq 0x24b639
movq 0x48(%r15), %rsi
movq %rbx, %rdi
callq 0x24b63f
movq 0x60(%r15), %rsi
movq %rbx, %rdi
callq 0x24b639
movq 0x78(%r15), %rsi
testq %rsi, %rsi
je 0x24b7f9
movq %rbx, %rdi
callq 0x24b8f5
movq 0x68(%r15), %rsi
testq %rsi, %rsi
je 0x24b80a
movq %rbx, %rdi
callq 0x24b91a
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x24b784
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22d0fc
xorl %ebp, %ebp
jmp 0x24b784
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x24b8f4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rsi), %r15
xorl %ebp, %ebp
cmpl (%rbx), %ebp
jge 0x24b8df
movq -0x58(%r15), %rsi
movq %r14, %rdi
callq 0x21f26b
movq -0x50(%r15), %rsi
movq %r14, %rdi
callq 0x21f26b
movq -0x48(%r15), %rsi
movq %r14, %rdi
callq 0x21f26b
movb -0x23(%r15), %al
testb $0x2, %al
je 0x24b895
movq (%r15), %rsi
movq %r14, %rdi
callq 0x21f26b
movb -0x23(%r15), %al
testb $0x4, %al
je 0x24b8a4
movq (%r15), %rsi
movq %r14, %rdi
callq 0x24b63f
movq -0x40(%r15), %rsi
movq %r14, %rdi
callq 0x21f182
movq -0x38(%r15), %rsi
movq %r14, %rdi
callq 0x24b6e9
movq -0x18(%r15), %rsi
movq %r14, %rdi
callq 0x24b639
movq -0x10(%r15), %rsi
movq %r14, %rdi
callq 0x24b97f
incl %ebp
addq $0x70, %r15
jmp 0x24b852
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22d0fc
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowListDelete
SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p){
  while( p ){
    Window *pNext = p->pNextWin;
    sqlite3WindowDelete(db, p);
    p = pNext;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x24b912
movq 0x40(%rsi), %r14
movq %rbx, %rdi
callq 0x24b6f4
movq %r14, %rsi
jmp 0x24b8fc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24b97e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %r15
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x24b968
movq -0x8(%r15), %rsi
movq %r14, %rdi
callq 0x24b63f
movq (%r15), %rsi
movq %r14, %rdi
callq 0x24b6e9
movq -0x10(%r15), %rsi
movq %r14, %rdi
callq 0x21f26b
incq %r12
addq $0x20, %r15
jmp 0x24b934
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22d0fc
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowUnlinkFromSelect
SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window *p){
  if( p->ppThis ){
    *p->ppThis = p->pNextWin;
    if( p->pNextWin ) p->pNextWin->ppThis = p->ppThis;
    p->ppThis = 0;
  }
}

// Assembly:
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x24b9fa
movq 0x40(%rdi), %rax
movq %rax, (%rcx)
testq %rax, %rax
je 0x24b9f5
movq 0x38(%rdi), %rcx
movq %rcx, 0x38(%rax)
andq $0x0, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %r14, %rdi
callq 0x24b639
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x21f26b
addq $0x18, %r15
decl %ebp
cmpl $0x1, %ebp
jg 0x24ba10
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22d0fc
// File: /workspace/github_c_makefile_star2_O2/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 0x24bc87
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 0x24bd15
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 0x24bce1
leaq 0x114819(%rip), %rsi    # 0x3604ef
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x220f53
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x24bcfa
movl 0x30(%rbx), %edx
movl 0x34(%rbx), %ecx
movq %r15, %rdi
xorl %eax, %eax
callq 0x221594
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x21f955
cmpb $0x7, 0x54(%rbx)
jne 0x24bd15
movl $0x1, 0x24(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x237626
testl %eax, %eax
je 0x24bd7e
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x24bd58
cmpl $0x7, %eax
jne 0x24bd60
movl $0x1, 0x24(%r14)
leaq 0x12afb6(%rip), %rsi    # 0x376d1d
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x24bc2c
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 0x24bd73
movzbl %r15b, %ecx
movl %eax, (%rsp)
leaq 0x12af95(%rip), %rsi    # 0x376d3a
movq %r14, %rdi
movl %ebx, %edx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x24bc2c
jmp 0x24bd73
// File: /workspace/github_c_makefile_star2_O2/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 0x24c4b8
movq 0x10(%rdi), %rax
movl %edx, %esi
shrl $0x3, %esi
movl %edx, %ecx
andb $0x7, %cl
pushq $0x1
popq %rbx
movl %ebx, %r8d
shll %cl, %r8d
movzbl (%rax,%rsi), %ecx
movl %edx, %r9d
andl $0x7, %r9d
btl %r9d, %ecx
jae 0x24c4cd
leaq 0x12a855(%rip), %rsi    # 0x376d04
xorl %eax, %eax
callq 0x24bc2c
jmp 0x24c4c9
leaq 0x12a82e(%rip), %rsi    # 0x376ced
xorl %eax, %eax
callq 0x24bc2c
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
movq 0x60(%rdi), %rdx
movl 0x168(%rdx), %edx
testl %edx, %edx
jne 0x24c4c9
orb %cl, %r8b
movb %r8b, (%rax,%rsi)
xorl %ebx, %ebx
jmp 0x24c4c9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: btreeHeapInsert
static void btreeHeapInsert(u32 *aHeap, u32 x){
  u32 j, i = ++aHeap[0];
  aHeap[i] = x;
  while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){
    x = aHeap[j];
    aHeap[j] = aHeap[i];
    aHeap[i] = x;
    i = j;
  }
}

// Assembly:
movl (%rdi), %eax
incl %eax
movl %eax, (%rdi)
movl %esi, (%rdi,%rax,4)
cmpl $0x2, %eax
jb 0x24c50f
movl %eax, %ecx
shrl %eax
movl %eax, %edx
movl (%rdi,%rdx,4), %esi
movl (%rdi,%rcx,4), %r8d
cmpl %r8d, %esi
jbe 0x24c50f
movl %r8d, (%rdi,%rdx,4)
movl %esi, (%rdi,%rcx,4)
jmp 0x24c4ef
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24c546
movq (%rsi), %r14
movq 0x8(%rbx), %rdi
callq 0x22d0fc
movq %r14, %rsi
jmp 0x24c530
andq $0x0, (%rbx)
movl $0x10000, 0x30(%rbx)    # imm = 0x10000
andq $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24c57a
movq 0x20(%rbx), %rax
decl %ecx
jmp 0x24c59e
movq 0x8(%rbx), %rdi
movl $0x3f8, %esi            # imm = 0x3F8
callq 0x22d205
testq %rax, %rax
je 0x24c5ac
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 0x24c5aa
// File: /workspace/github_c_makefile_star2_O2/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 $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x140, %edx            # imm = 0x140
xorl %esi, %esi
callq 0x17380
testq %rbx, %rbx
je 0x24c609
movq 0x8(%rbx), %r14
andq $0x0, 0x8(%rbx)
xorl %eax, %eax
movl %eax, %r15d
movq (%rsp,%r15,8), %rdi
testq %rdi, %rdi
je 0x24c600
movq %rbx, %rsi
callq 0x24c643
movq %rax, %rbx
andq $0x0, (%rsp,%r15,8)
leal 0x1(%r15), %eax
jmp 0x24c5de
movq %rbx, (%rsp,%r15,8)
movq %r14, %rbx
jmp 0x24c5ce
pushq $0x1
popq %rbx
movq (%rsp), %rax
cmpq $0x28, %rbx
je 0x24c636
movq (%rsp,%rbx,8), %rsi
testq %rsi, %rsi
je 0x24c631
testq %rax, %rax
je 0x24c62e
movq %rax, %rdi
callq 0x24c643
jmp 0x24c631
movq %rsi, %rax
incq %rbx
jmp 0x24c610
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x24c776
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x2, %esi
jl 0x24c77a
decl %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x24c731
movq (%r14), %rbx
testq %rbx, %rbx
je 0x24c78a
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x24c731
movq %rax, 0x8(%rbx)
jmp 0x24c78d
xorl %ebx, %ebx
jmp 0x24c78d
movq 0x8(%rbx), %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x24c78d
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x24c7f4
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 0x22efaa
testq %rax, %rax
je 0x24c844
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x24c946
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22d0fc
jmp 0x24c847
pushq $0x7
popq %rbp
movl %ebp, %eax
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $-0x1
popq %rax
movq %rsp, %rcx
movq %rdx, %rsi
movl %eax, %edx
xorl %r8d, %r8d
callq 0x228088
movl %eax, %ebp
testl %eax, %eax
jne 0x24c9f3
movq (%rsp), %r15
movq %r15, %rdi
callq 0x224bf7
cmpl $0x64, %eax
jne 0x24c9c9
movq %r15, %rdi
xorl %esi, %esi
callq 0x225a90
testq %rax, %rax
je 0x24c974
movzbl (%rax), %ecx
cmpl $0x49, %ecx
je 0x24c9ab
cmpl $0x43, %ecx
jne 0x24c974
cmpb $0x52, 0x1(%rax)
jne 0x24c974
cmpb $0x45, 0x2(%rax)
jne 0x24c974
jmp 0x24c9b7
cmpb $0x4e, 0x1(%rax)
jne 0x24c974
cmpb $0x53, 0x2(%rax)
jne 0x24c974
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x24c946
testl %eax, %eax
je 0x24c974
xorl %ebp, %ebp
cmpl $0x65, %eax
cmovnel %eax, %ebp
testl %ebp, %ebp
je 0x24c9eb
movq %rbx, %rdi
callq 0x2280b1
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x24a76d
movq %r15, %rdi
callq 0x224044
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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), %rcx
pushq $0x5
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
xorl %ebx, %ebx
testl %edx, %edx
jne 0x24caac
movq %rdi, %r14
leaq 0x28(,%rcx,8), %rdx
movq 0x210(%rdi), %rsi
callq 0x22d1b5
testq %rax, %rax
je 0x24caa9
movslq 0x1ec(%r14), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
andq $0x0, 0x20(%rax,%rcx,8)
movq %rax, 0x210(%r14)
jmp 0x24caac
pushq $0x7
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24cee1
movq %rdi, %r15
movl 0x4(%rdi), %ebp
movslq %edx, %r12
pushq $0x2
popq %rbx
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 0x17310
testl %eax, %eax
jne 0x24ced2
cmpb $0x0, (%r13,%r12)
je 0x24cede
addl 0x4(%r14), %ebx
cmpl %ebp, %ebx
jl 0x24cea8
xorl %eax, %eax
jmp 0x24cee1
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_O2/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
pushq $0x2a
popq %rax
cmovneq %rcx, %rax
movq 0x18(%rdi), %r15
movq (%r15), %rdi
movslq 0x90(%rdi), %rcx
cmpq %rcx, %rax
jle 0x24d5e8
callq 0x224bb1
jmp 0x24d62a
movq 0x88(%rbx), %rsi
imulq $0x18, %rax, %rdx
callq 0x22d1b5
testq %rax, %rax
je 0x24d62a
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0x22103d
movl %eax, 0x3c(%r15)
cltq
xorl %ecx, %ecx
pushq $0x18
popq %rsi
xorl %edx, %edx
divq %rsi
movl %eax, 0x94(%rbx)
movq %r14, 0x88(%rbx)
jmp 0x24d62d
pushq $0x7
popq %rcx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsbl 0x1(%rsi), %esi
testl %esi, %esi
je 0x24d665
movq (%r15), %rdi
movq 0x10(%r14), %rdx
callq 0x238761
movb $0x0, 0x1(%r14)
andq $0x0, 0x10(%r14)
testl %ebp, %ebp
js 0x24d696
jne 0x24d675
movq %rbx, %rdi
callq 0x2211ac
movl %eax, %ebp
movq (%r15), %rdi
movl %ebp, %edx
movq %rbx, %rsi
callq 0x24b168
movq %rax, 0x10(%r14)
movb $-0x7, 0x1(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
subq 0x88(%r15), %r14
pushq $0x18
popq %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %r15, %rdi
movl %eax, %esi
movq %rbx, %rdx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2270ee
// File: /workspace/github_c_makefile_star2_O2/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, %r15d
movq %rdi, %r14
movq (%rdi), %rbx
movzwl 0xc0(%rdi), %esi
testl %esi, %esi
je 0x24d80d
movq 0x98(%r14), %rdi
addl %esi, %esi
callq 0x238689
movq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x21f26b
leal (%r15,%r15), %ebp
movw %r15w, 0xc0(%r14)
movslq %ebp, %rax
imulq $0x38, %rax, %rsi
movq %rbx, %rdi
callq 0x22d205
movq %rax, 0x98(%r14)
testq %rax, %rax
je 0x24d84b
pushq $0x1
popq %rcx
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24d88e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: initMemArray
static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){
  while( (N--)>0 ){
    p->db = db;
    p->flags = flags;
    p->szMalloc = 0;
#ifdef SQLITE_DEBUG
    p->pScopyFrom = 0;
#endif
    p++;
  }
}

// Assembly:
addq $0x28, %rdi
testl %esi, %esi
jle 0x24d8a9
decl %esi
movq %rdx, (%rdi)
movw %cx, -0x20(%rdi)
andl $0x0, -0x8(%rdi)
addq $0x38, %rdi
jmp 0x24d892
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpb $0x1, (%rdi)
jne 0x24d8bb
pushq $0x4
popq %rax
jmp 0x24d8cf
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0x2452c2
testl %eax, %eax
je 0x24d8da
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 0x2371d5
// File: /workspace/github_c_makefile_star2_O2/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 0x24d936
movq %rdi, %r15
leaq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x22be24
testl %eax, %eax
je 0x24d92a
movl %eax, 0x18(%r15)
incl 0x30(%r15)
movl %eax, %ebx
jmp 0x24d936
cmpb $0x0, 0x69(%r14)
je 0x24d936
orb $0x10, 0x2c(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x40
popq %r12
xorl %r13d, %r13d
leaq 0x1e8336(%rip), %r15    # 0x435c90
xorl %r14d, %r14d
cmpl %r12d, %r13d
jg 0x24d99e
leal (%r12,%r13), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movl %eax, %r14d
movslq %eax, %rbp
imulq $0x18, %rbp, %rax
movq (%rax,%r15), %rsi
movq %rbx, %rdi
callq 0x221763
testl %eax, %eax
je 0x24d9a1
movl %r14d, %ecx
incl %ecx
testl %eax, %eax
cmovsl %r13d, %ecx
leal -0x1(%r14), %eax
cmovsl %eax, %r12d
movl %ecx, %r13d
jmp 0x24d95d
movslq %r14d, %rbp
imulq $0x18, %rbp, %rax
addq %rax, %r15
xorl %eax, %eax
cmpl %r12d, %r13d
cmovleq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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, %r13
movq %rdi, %rbx
testq %rdx, %rdx
je 0x24da4d
movq %r8, %r15
movq %rdx, %rbp
movq %rcx, 0x10(%rsp)
movq %r13, %rdi
callq 0x2211ac
movl %eax, %r12d
leal 0x31(%r12), %edi
callq 0x21f6df
testq %rax, %rax
je 0x24da87
movq %rax, %r14
movq %r15, 0x8(%rsp)
movq %rax, %r15
addq $0x30, %r15
incl %r12d
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x17630
movq %r15, 0x8(%r14)
movq %rbp, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r14)
andq $0x0, 0x28(%r14)
movl $0x1, 0x10(%r14)
movq %r15, %r13
jmp 0x24da50
xorl %r14d, %r14d
leaq 0x1f0(%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x24a8f4
testq %rax, %rax
je 0x24daa4
movq %rax, %r15
movq %rbx, %rdi
cmpq %r14, %rax
je 0x24da91
movq %r15, %rsi
callq 0x24dab6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x23887c
jmp 0x24daa4
movq %rbx, %rdi
callq 0x224bb1
jmp 0x24daa1
callq 0x224bb1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22d0fc
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VtabEponymousTableClear
SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){
  Table *pTab = pMod->pEpoTab;
  if( pTab!=0 ){
    /* Mark the table as Ephemeral prior to deleting it, so that the
    ** sqlite3DeleteTable() routine will know that it is not stored in
    ** the schema. */
    pTab->tabFlags |= TF_Ephemeral;
    sqlite3DeleteTable(db, pTab);
    pMod->pEpoTab = 0;
  }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rsi), %rsi
testq %rsi, %rsi
je 0x24dad1
orb $0x2, 0x40(%rsi)
callq 0x21f182
andq $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabBestIndex
static int pragmaVtabBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
  PragmaVtab *pTab = (PragmaVtab*)tab;
  const struct sqlite3_index_constraint *pConstraint;
  int i, j;
  int seen[2];

  pIdxInfo->estimatedCost = (double)1;
  if( pTab->nHidden==0 ){ return SQLITE_OK; }
  pConstraint = pIdxInfo->aConstraint;
  seen[0] = 0;
  seen[1] = 0;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    if( pConstraint->usable==0 ) continue;
    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( pConstraint->iColumn < pTab->iHidden ) continue;
    j = pConstraint->iColumn - pTab->iHidden;
    assert( j < 2 );
    seen[j] = i+1;
  }
  if( seen[0]==0 ){
    pIdxInfo->estimatedCost = (double)2147483647;
    pIdxInfo->estimatedRows = 2147483647;
    return SQLITE_OK;
  }
  j = seen[0]-1;
  pIdxInfo->aConstraintUsage[j].argvIndex = 1;
  pIdxInfo->aConstraintUsage[j].omit = 1;
  if( seen[1]==0 ) return SQLITE_OK;
  pIdxInfo->estimatedCost = (double)20;
  pIdxInfo->estimatedRows = 20;
  j = seen[1]-1;
  pIdxInfo->aConstraintUsage[j].argvIndex = 2;
  pIdxInfo->aConstraintUsage[j].omit = 1;
  return SQLITE_OK;
}

// Assembly:
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x40(%rsi)
cmpb $0x0, 0x28(%rdi)
je 0x24dd4f
movq 0x8(%rsi), %rax
andq $0x0, -0x8(%rsp)
movl (%rsi), %ecx
addq $0x5, %rax
movl $0x1, %edx
leal -0x1(%rdx), %r8d
cmpl %ecx, %r8d
jge 0x24dcef
cmpb $0x0, (%rax)
je 0x24dce7
cmpb $0x2, -0x1(%rax)
jne 0x24dce7
movslq -0x5(%rax), %r8
movzbl 0x29(%rdi), %r9d
cmpl %r9d, %r8d
jl 0x24dce7
subq %r9, %r8
movl %edx, -0x8(%rsp,%r8,4)
addq $0xc, %rax
incl %edx
jmp 0x24dcbd
movslq -0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x24dd39
movq 0x20(%rsi), %rax
movl $0x1, -0x8(%rax,%rcx,8)
movb $0x1, -0x4(%rax,%rcx,8)
movslq -0x4(%rsp), %rcx
testq %rcx, %rcx
je 0x24dd4f
movabsq $0x4034000000000000, %rdx # imm = 0x4034000000000000
movq %rdx, 0x40(%rsi)
movq $0x14, 0x48(%rsi)
movl $0x2, -0x8(%rax,%rcx,8)
movb $0x1, -0x4(%rax,%rcx,8)
jmp 0x24dd4f
movabsq $0x41dfffffffc00000, %rax # imm = 0x41DFFFFFFFC00000
movq %rax, 0x40(%rsi)
movq $0x7fffffff, 0x48(%rsi) # imm = 0x7FFFFFFF
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabOpen
static int pragmaVtabOpen(sqlite3_vtab *pVtab, sqlite3_vtab_cursor **ppCursor){
  PragmaVtabCursor *pCsr;
  pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr));
  if( pCsr==0 ) return SQLITE_NOMEM;
  memset(pCsr, 0, sizeof(PragmaVtabCursor));
  pCsr->base.pVtab = pVtab;
  *ppCursor = &pCsr->base;
  return SQLITE_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x21f6c0
testq %rax, %rax
je 0x24dd88
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %r14, (%rax)
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x24dd8b
pushq $0x7
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabClose
static int pragmaVtabClose(sqlite3_vtab_cursor *cur){
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)cur;
  pragmaVtabCursorClear(pCsr);
  sqlite3_free(pCsr);
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x24dfbd
movq %rbx, %rdi
callq 0x21f7f9
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabNext
static int pragmaVtabNext(sqlite3_vtab_cursor *pVtabCursor){
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
  int rc = SQLITE_OK;

  /* Increment the xRowid value */
  pCsr->iRowid++;
  assert( pCsr->pPragma );
  if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){
    rc = sqlite3_finalize(pCsr->pPragma);
    pCsr->pPragma = 0;
    pragmaVtabCursorClear(pCsr);
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq 0x10(%rdi)
movq 0x8(%rdi), %rdi
callq 0x224bf7
cmpl $0x64, %eax
jne 0x24df43
xorl %eax, %eax
jmp 0x24df5d
movq 0x8(%rbx), %rdi
callq 0x224044
movl %eax, %ebp
andq $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x24dfbd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabColumn
static int pragmaVtabColumn(
  sqlite3_vtab_cursor *pVtabCursor,
  sqlite3_context *ctx,
  int i
){
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
  PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
  if( i<pTab->iHidden ){
    sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i));
  }else{
    sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
movzbl 0x29(%rax), %eax
cmpl %eax, %edx
jge 0x24df96
movq 0x8(%rdi), %rdi
movl %edx, %esi
callq 0x225aba
movq %rbx, %rdi
movq %rax, %rsi
callq 0x224a29
jmp 0x24dfaf
movslq %edx, %rcx
subq %rax, %rcx
movq 0x18(%rdi,%rcx,8), %rsi
pushq $-0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
callq 0x2249c3
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabCursorClear
static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){
  int i;
  sqlite3_finalize(pCsr->pPragma);
  pCsr->pPragma = 0;
  for(i=0; i<ArraySize(pCsr->azArg); i++){
    sqlite3_free(pCsr->azArg[i]);
    pCsr->azArg[i] = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x224044
andq $0x0, 0x8(%rbx)
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x24dff0
movq 0x18(%rbx,%r14,8), %rdi
callq 0x21f7f9
andq $0x0, 0x18(%rbx,%r14,8)
incq %r14
jmp 0x24dfd5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: addModuleArgument
static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){
  sqlite3_int64 nBytes = sizeof(char *)*(2+pTable->nModuleArg);
  char **azModuleArg;
  sqlite3 *db = pParse->db;
  if( pTable->nModuleArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
  }
  azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
  if( azModuleArg==0 ){
    sqlite3DbFree(db, zArg);
  }else{
    int i = pTable->nModuleArg++;
    azModuleArg[i] = zArg;
    azModuleArg[i+1] = 0;
    pTable->azModuleArg = azModuleArg;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movslq 0x54(%rsi), %rax
leaq 0x10(,%rax,8), %r12
movq (%rdi), %r15
addl $0x3, %eax
cmpl 0x84(%r15), %eax
jl 0x24e032
movq (%r14), %rdx
leaq 0x129690(%rip), %rsi    # 0x3776bb
xorl %eax, %eax
callq 0x226dce
movq 0x58(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x22d1b5
testq %rax, %rax
je 0x24e06c
movslq 0x54(%r14), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x54(%r14)
movq %rbx, (%rax,%rcx,8)
andq $0x0, 0x8(%rax,%rcx,8)
movq %rax, 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21f26b
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CollapseDatabaseArray
SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){
  int i, j;
  for(i=j=2; i<db->nDb; i++){
    struct Db *pDb = &db->aDb[i];
    if( pDb->pBt==0 ){
      sqlite3DbFree(db, pDb->zDbSName);
      pDb->zDbSName = 0;
      continue;
    }
    if( j<i ){
      db->aDb[j] = db->aDb[i];
    }
    j++;
  }
  db->nDb = j;
  if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
    memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
    sqlite3DbFree(db, db->aDb);
    db->aDb = db->aDbStatic;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x2
popq %rbp
pushq $0x2
popq %r14
pushq $0x40
popq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jge 0x24e0ef
movq 0x20(%rbx), %rax
leaq (%rax,%r15), %r12
cmpq $0x0, 0x8(%rax,%r15)
je 0x24e0d5
movslq %ebp, %rcx
cmpq %rcx, %r14
jle 0x24e0d1
shlq $0x5, %rcx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incl %ebp
jmp 0x24e0e6
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x21f26b
andq $0x0, (%r12)
incq %r14
addq $0x20, %r15
jmp 0x24e098
movl %ebp, 0x28(%rbx)
cmpl $0x2, %ebp
jg 0x24e135
movq 0x20(%rbx), %rsi
leaq 0x268(%rbx), %r14
cmpq %r14, %rsi
je 0x24e135
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x30(%rsi), %xmm3
movups %xmm3, 0x30(%r14)
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbx, %rdi
callq 0x21f26b
movq %r14, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DeleteColumnNames
SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
  int i;
  Column *pCol;
  assert( pTable!=0 );
  if( (pCol = pTable->aCol)!=0 ){
    for(i=0; i<pTable->nCol; i++, pCol++){
      assert( pCol->zName==0 || pCol->hName==sqlite3StrIHash(pCol->zName) );
      sqlite3DbFree(db, pCol->zName);
      sqlite3ExprDelete(db, pCol->pDflt);
      sqlite3DbFree(db, pCol->zColl);
    }
    sqlite3DbFree(db, pTable->aCol);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x24e318
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movswl 0x46(%r14), %eax
cmpl %eax, %ebp
jge 0x24e302
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x21f26b
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x24b639
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x21f26b
incl %ebp
addq $0x20, %r15
jmp 0x24e2ce
movq 0x8(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21f26b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DeleteTriggerStep
SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
  while( pTriggerStep ){
    TriggerStep * pTmp = pTriggerStep;
    pTriggerStep = pTriggerStep->pNext;

    sqlite3ExprDelete(db, pTmp->pWhere);
    sqlite3ExprListDelete(db, pTmp->pExprList);
    sqlite3SelectDelete(db, pTmp->pSelect);
    sqlite3IdListDelete(db, pTmp->pIdList);
    sqlite3UpsertDelete(db, pTmp->pUpsert);
    sqlite3SrcListDelete(db, pTmp->pFrom);
    sqlite3DbFree(db, pTmp->zSpan);

    sqlite3DbFree(db, pTmp);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %r14, %r14
je 0x24e4a9
movq 0x28(%r14), %rsi
movq 0x50(%r14), %r15
movq %rbx, %rdi
callq 0x24b639
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x24b63f
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x24b6e9
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x24b97f
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x24e4af
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x24b836
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x21f26b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0fc
movq %r15, %r14
jmp 0x24e43c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3UpsertDelete
SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){
  if( p ){
    sqlite3ExprListDelete(db, p->pUpsertTarget);
    sqlite3ExprDelete(db, p->pUpsertTargetWhere);
    sqlite3ExprListDelete(db, p->pUpsertSet);
    sqlite3ExprDelete(db, p->pUpsertWhere);
    sqlite3DbFree(db, p);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x24e4fc
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x24b63f
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x24b639
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x24b63f
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x24b639
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d0fc
retq