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: pagerPagecount
static int pagerPagecount(Pager *pPager, Pgno *pnPage){
  Pgno nPage;                     /* Value to return via *pnPage */

  /* Query the WAL sub-system for the database size. The WalDbsize()
  ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
  ** if the database size is not available. The database size is not
  ** available from the WAL sub-system if the log file is empty or
  ** contains no valid committed transactions.
  */
  assert( pPager->eState==PAGER_OPEN );
  assert( pPager->eLock>=SHARED_LOCK );
  assert( isOpen(pPager->fd) );
  assert( pPager->tempFile==0 );
  nPage = sqlite3WalDbsize(pPager->pWal);

  /* If the number of pages in the database is not available from the
  ** WAL sub-system, determine the page count based on the size of
  ** the database file.  If the size of the database file is not an
  ** integer multiple of the page-size, round up the result.
  */
  if( nPage==0 && ALWAYS(isOpen(pPager->fd)) ){
    i64 n = 0;                    /* Size of db file in bytes */
    int rc = sqlite3OsFileSize(pPager->fd, &n);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
  }

  /* If the current number of pages in the file is greater than the
  ** configured maximum pager number, increase the allowed limit so
  ** that the file can be read.
  */
  if( nPage>pPager->mxPgno ){
    pPager->mxPgno = (Pgno)nPage;
  }

  *pnPage = nPage;
  return SQLITE_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x120(%rdi), %rax
testq %rax, %rax
je 0x28d072
cmpw $0x0, 0x3c(%rax)
js 0x28d072
movl 0x5c(%rax), %eax
testl %eax, %eax
jne 0x28d0a5
movq 0x48(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x28d0b7
movq %rsp, %rsi
movq $0x0, (%rsi)
callq *0x30(%rax)
testl %eax, %eax
jne 0x28d0bd
movq (%rsp), %rax
movslq 0xbc(%r14), %rcx
addq %rcx, %rax
decq %rax
cqto
idivq %rcx
cmpl 0xc0(%r14), %eax
jbe 0x28d0b9
movl %eax, 0xc0(%r14)
jmp 0x28d0b9
xorl %eax, %eax
movl %eax, (%rbx)
xorl %eax, %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: saveAllCursors
static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
  BtCursor *p;
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( pExcept==0 || pExcept->pBt==pBt );
  for(p=pBt->pCursor; p; p=p->pNext){
    if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ) break;
  }
  if( p ) return saveCursorsOnList(p, iRoot, pExcept);
  if( pExcept ) pExcept->curFlags &= ~BTCF_Multiple;
  return SQLITE_OK;
}

// Assembly:
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x28dd8e
cmpq %rdx, %rdi
je 0x28dd88
testl %esi, %esi
je 0x28e021
cmpl %esi, 0x50(%rdi)
je 0x28e021
movq 0x28(%rdi), %rdi
jmp 0x28dd6d
testq %rdx, %rdx
je 0x28dd97
andb $-0x21, 0x1(%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: saveCursorsOnList
static int SQLITE_NOINLINE saveCursorsOnList(
  BtCursor *p,         /* The first cursor that needs saving */
  Pgno iRoot,          /* Only save cursor with this iRoot. Save all if zero */
  BtCursor *pExcept    /* Do not save this cursor */
){
  do{
    if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){
      if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
        int rc = saveCursorPosition(p);
        if( SQLITE_OK!=rc ){
          return rc;
        }
      }else{
        testcase( p->iPage>=0 );
        btreeReleaseAllCursorPages(p);
      }
    }
    p = p->pNext;
  }while( p );
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpq %rbx, %r14
je 0x28e057
testl %ebp, %ebp
je 0x28e03c
cmpl %ebp, 0x50(%r14)
jne 0x28e057
movzbl (%r14), %eax
movq %r14, %rdi
testb $-0x3, %al
jne 0x28e052
callq 0x28e067
testl %eax, %eax
je 0x28e057
jmp 0x28e062
callq 0x28e0af
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x28e02d
xorl %eax, %eax
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: saveCursorPosition
static int saveCursorPosition(BtCursor *pCur){
  int rc;

  assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
  assert( 0==pCur->pKey );
  assert( cursorHoldsMutex(pCur) );

  if( pCur->curFlags & BTCF_Pinned ){
    return SQLITE_CONSTRAINT_PINNED;
  }
  if( pCur->eState==CURSOR_SKIPNEXT ){
    pCur->eState = CURSOR_VALID;
  }else{
    pCur->skipNext = 0;
  }

  rc = saveCursorKey(pCur);
  if( rc==SQLITE_OK ){
    btreeReleaseAllCursorPages(pCur);
    pCur->eState = CURSOR_REQUIRESEEK;
  }

  pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl|BTCF_AtLast);
  return rc;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0xb13, %ebp            # imm = 0xB13
testb $0x40, 0x1(%rdi)
jne 0x28e0a6
movq %rdi, %rbx
cmpb $0x2, (%rdi)
jne 0x28e082
movb $0x0, (%rbx)
jmp 0x28e089
movl $0x0, 0x4(%rbx)
movq %rbx, %rdi
callq 0x28e0fb
movl %eax, %ebp
testl %eax, %eax
jne 0x28e0a2
movq %rbx, %rdi
callq 0x28e0af
movb $0x3, (%rbx)
andb $-0xf, 0x1(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: btreeReleaseAllCursorPages
static void btreeReleaseAllCursorPages(BtCursor *pCur){
  int i;
  if( pCur->iPage>=0 ){
    for(i=0; i<pCur->iPage; i++){
      releasePageNotNull(pCur->apPage[i]);
    }
    releasePageNotNull(pCur->pPage);
    pCur->iPage = -1;
  }
}

// Assembly:
cmpb $0x0, 0x54(%rdi)
js 0x28e0fa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
je 0x28e0df
xorl %r14d, %r14d
movq 0x90(%rbx,%r14,8), %rax
movq 0x70(%rax), %rdi
callq 0x28ab87
incq %r14
movsbq 0x54(%rbx), %rax
cmpq %rax, %r14
jl 0x28e0c1
movq 0x88(%rbx), %rax
movq 0x70(%rax), %rdi
callq 0x28ab87
movb $-0x1, 0x54(%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: saveCursorKey
static int saveCursorKey(BtCursor *pCur){
  int rc = SQLITE_OK;
  assert( CURSOR_VALID==pCur->eState );
  assert( 0==pCur->pKey );
  assert( cursorHoldsMutex(pCur) );

  if( pCur->curIntKey ){
    /* Only the rowid is required for a table btree */
    pCur->nKey = sqlite3BtreeIntegerKey(pCur);
  }else{
    /* For an index btree, save the complete key content. It is possible
    ** that the current key is corrupt. In that case, it is possible that
    ** the sqlite3VdbeRecordUnpack() function may overread the buffer by
    ** up to the size of 1 varint plus 1 8-byte value when the cursor
    ** position is restored. Hence the 17 bytes of padding allocated
    ** below. */
    void *pKey;
    pCur->nKey = sqlite3BtreePayloadSize(pCur);
    pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
    if( pKey ){
      rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
      if( rc==SQLITE_OK ){
        memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
        pCur->pKey = pKey;
      }else{
        sqlite3_free(pKey);
      }
    }else{
      rc = SQLITE_NOMEM_BKPT;
    }
  }
  assert( !pCur->curIntKey || !pCur->pKey );
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x55(%rdi), %bpl
callq 0x28e1b0
testb %bpl, %bpl
je 0x28e12a
movq 0x30(%rbx), %rax
movq %rax, 0x48(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x40(%rbx), %edi
movq %rdi, 0x48(%rbx)
addq $0x11, %rdi
callq 0x272ae6
testq %rax, %rax
je 0x28e18e
movq %rax, %r14
movl 0x48(%rbx), %edx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x28e1f6
testl %eax, %eax
je 0x28e195
movl %eax, %r15d
cmpl $0x0, 0x22d4fb(%rip)    # 0x4bb660
je 0x28e180
movq %r14, %rdi
callq *0x22d528(%rip)         # 0x4bb698
cltq
subq %rax, 0x23097f(%rip)    # 0x4beaf8
decq 0x2309c0(%rip)          # 0x4beb40
movq %r14, %rdi
callq *0x22d4ff(%rip)         # 0x4bb688
movl %r15d, %ebp
jmp 0x28e11d
movl $0x7, %ebp
jmp 0x28e11d
movq 0x48(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%r14,%rax)
movb $0x0, 0x10(%r14,%rax)
movq %r14, 0x18(%rbx)
jmp 0x28e11d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: btreeGetUnusedPage
static int btreeGetUnusedPage(
  BtShared *pBt,       /* The btree */
  Pgno pgno,           /* Number of the page to fetch */
  MemPage **ppPage,    /* Return the page in this parameter */
  int flags            /* PAGER_GET_NOCONTENT or PAGER_GET_READONLY */
){
  int rc = btreeGetPage(pBt, pgno, ppPage, flags);
  if( rc==SQLITE_OK ){
    if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
      releasePage(*ppPage);
      *ppPage = 0;
      return SQLITE_CORRUPT_BKPT;
    }
    (*ppPage)->isInit = 0;
  }else{
    *ppPage = 0;
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
callq 0x28ced9
testl %eax, %eax
je 0x28f31d
movl %eax, %ebp
movq $0x0, (%rbx)
jmp 0x28f369
movq (%rbx), %rax
movq 0x70(%rax), %rdi
cmpw $0x2, 0x36(%rdi)
jl 0x28f364
callq 0x28ab87
movq $0x0, (%rbx)
leaq 0x14688d(%rip), %rsi    # 0x3d5bcb
leaq 0x146997(%rip), %rdx    # 0x3d5cdc
leaq 0x1466e5(%rip), %r8     # 0x3d5a31
movl $0xb, %ebp
movl $0xb, %edi
movl $0x104bb, %ecx          # imm = 0x104BB
xorl %eax, %eax
callq 0x274d08
jmp 0x28f369
movb $0x0, (%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: setChildPtrmaps
static int setChildPtrmaps(MemPage *pPage){
  int i;                             /* Counter variable */
  int nCell;                         /* Number of cells in page pPage */
  int rc;                            /* Return code */
  BtShared *pBt = pPage->pBt;
  Pgno pgno = pPage->pgno;

  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
  if( rc!=SQLITE_OK ) return rc;
  nCell = pPage->nCell;

  for(i=0; i<nCell; i++){
    u8 *pCell = findCell(pPage, i);

    ptrmapPutOvflPtr(pPage, pPage, pCell, &rc);

    if( !pPage->leaf ){
      Pgno childPgno = get4byte(pCell);
      ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
    }
  }

  if( !pPage->leaf ){
    Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
    ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
  }

  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x48(%rdi), %r14
movl 0x4(%rdi), %eax
movl %eax, 0x4(%rsp)
cmpb $0x0, (%rdi)
je 0x28f433
movl $0x0, (%rsp)
movzwl 0x18(%r15), %ebp
testq %rbp, %rbp
je 0x28f404
xorl %ebx, %ebx
movq %rsp, %r12
movzwl 0x1a(%r15), %eax
movq 0x60(%r15), %rcx
movzbl (%rcx,%rbx,2), %edx
shll $0x8, %edx
movzbl 0x1(%rcx,%rbx,2), %r13d
orl %edx, %r13d
andl %eax, %r13d
addq 0x50(%r15), %r13
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x28f905
cmpb $0x0, 0x8(%r15)
jne 0x28f3fc
movl (%r13), %esi
bswapl %esi
movq %r14, %rdi
movl $0x5, %edx
movl 0x4(%rsp), %ecx
movq %r12, %r8
callq 0x28f455
incq %rbx
cmpq %rbx, %rbp
jne 0x28f3aa
cmpb $0x0, 0x8(%r15)
jne 0x28f42e
movq 0x50(%r15), %rax
movzbl 0x9(%r15), %ecx
movl 0x8(%rax,%rcx), %esi
bswapl %esi
movq %rsp, %r8
movq %r14, %rdi
movl $0x5, %edx
movl 0x4(%rsp), %ecx
callq 0x28f455
movl (%rsp), %eax
jmp 0x28f446
movq %r15, %rdi
callq 0x28b010
movl %eax, (%rsp)
testl %eax, %eax
je 0x28f39b
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: sqlite3PcacheMove
SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
  PCache *pCache = p->pCache;
  assert( p->nRef>0 );
  assert( newPgno>0 );
  assert( sqlite3PcachePageSanity(p) );
  pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno));
  sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
  p->pgno = newPgno;
  if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
    pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x18(%rdi), %rax
movq 0x40(%rax), %rdi
movl 0x30(%rbx), %edx
movl %ebp, %ecx
callq *0x22bf5f(%rip)         # 0x4bb750
movl %ebp, 0x30(%rbx)
movl 0x34(%rbx), %eax
notl %eax
testb $0xa, %al
jne 0x28f810
movq %rbx, %rdi
movl $0x3, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x288c8c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: ptrmapPutOvflPtr
static void ptrmapPutOvflPtr(MemPage *pPage, MemPage *pSrc, u8 *pCell,int *pRC){
  CellInfo info;
  if( *pRC ) return;
  assert( pCell!=0 );
  pPage->xParseCell(pPage, pCell, &info);
  if( info.nLocal<info.nPayload ){
    Pgno ovfl;
    if( SQLITE_WITHIN(pSrc->aDataEnd, pCell, pCell+info.nLocal) ){
      testcase( pSrc!=pPage );
      *pRC = SQLITE_CORRUPT_BKPT;
      return;
    }
    ovfl = get4byte(&pCell[info.nSize-4]);
    ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
  }
}

// Assembly:
cmpl $0x0, (%rcx)
je 0x28f90b
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rsp), %r13
movq %rdx, %rsi
movq %r13, %rdx
callq *0x80(%rdi)
movzwl 0x14(%r13), %eax
cmpl %eax, 0x10(%r13)
jbe 0x28f9a1
movq 0x58(%r12), %rcx
cmpq %r15, %rcx
jb 0x28f980
addq %r15, %rax
cmpq %rax, %rcx
jae 0x28f980
leaq 0x146272(%rip), %rsi    # 0x3d5bcb
leaq 0x14637c(%rip), %rdx    # 0x3d5cdc
leaq 0x1460ca(%rip), %r8     # 0x3d5a31
movl $0xb, %edi
movl $0x1014d, %ecx          # imm = 0x1014D
xorl %eax, %eax
callq 0x274d08
movl $0xb, (%rbx)
jmp 0x28f9a1
movzwl 0x1e(%rsp), %eax
movl -0x4(%r15,%rax), %esi
bswapl %esi
movq 0x48(%r14), %rdi
movl 0x4(%r14), %ecx
movl $0x3, %edx
movq %rbx, %r8
callq 0x28f455
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeTripAllCursors
SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){
  BtCursor *p;
  int rc = SQLITE_OK;

  assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 );
  if( pBtree ){
    sqlite3BtreeEnter(pBtree);
    for(p=pBtree->pBt->pCursor; p; p=p->pNext){
      if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){
        if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
          rc = saveCursorPosition(p);
          if( rc!=SQLITE_OK ){
            (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0);
            break;
          }
        }
      }else{
        sqlite3BtreeClearCursor(p);
        p->eState = CURSOR_FAULT;
        p->skipNext = errCode;
      }
      btreeReleaseAllCursorPages(p);
    }
    sqlite3BtreeLeave(pBtree);
  }
  return rc;
}

// Assembly:
testq %rdi, %rdi
je 0x28fa6e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %r14
testq %r14, %r14
setne %r15b
je 0x28fa71
movl %esi, %ebp
testl %edx, %edx
sete %r13b
xorl %r12d, %r12d
testb $0x1, %r13b
jne 0x28fa3b
testb $0x1, 0x1(%r14)
jne 0x28fa3b
movzbl (%r14), %eax
testb $-0x3, %al
jne 0x28fa54
movq %r14, %rdi
callq 0x28e067
testl %eax, %eax
je 0x28fa54
testb $0x1, %r12b
movl 0x4(%rsp), %ecx
cmovel %eax, %ecx
movl %ecx, 0x4(%rsp)
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq 0x10(%rdx), %r14
movb $0x1, %r13b
movl %eax, %ebp
movb $0x1, %r12b
testq %r14, %r14
jne 0x28f9ed
jmp 0x28fa68
movq 0x18(%r14), %rdi
callq 0x272c00
movq $0x0, 0x18(%r14)
movb $0x4, (%r14)
movl %ebp, 0x4(%r14)
movq %r14, %rdi
callq 0x28e0af
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x28f9ed
movl %r12d, %r15d
movl 0x4(%rsp), %ecx
jmp 0x28fa71
xorl %eax, %eax
retq
xorl %eax, %eax
testb $0x1, %r15b
cmovnel %ecx, %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: releaseMemArray
static void releaseMemArray(Mem *p, int N){
  if( p && N ){
    Mem *pEnd = &p[N];
    sqlite3 *db = p->db;
    if( db->pnBytesFreed ){
      do{
        if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
      }while( (++p)<pEnd );
      return;
    }
    do{
      assert( (&p[1])==pEnd || p[0].db==p[1].db );
      assert( sqlite3VdbeCheckMemInvariants(p) );

      /* This block is really an inlined version of sqlite3VdbeMemRelease()
      ** that takes advantage of the fact that the memory cell value is
      ** being set to NULL after releasing any dynamic resources.
      **
      ** The justification for duplicating code is that according to
      ** callgrind, this causes a certain test case to hit the CPU 4.7
      ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
      ** sqlite3MemRelease() were called from here. With -O2, this jumps
      ** to 6.6 percent. The test case is inserting 1000 rows into a table
      ** with no indexes using a single prepared INSERT statement, bind()
      ** and reset(). Inserts are grouped into a transaction.
      */
      testcase( p->flags & MEM_Agg );
      testcase( p->flags & MEM_Dyn );
      testcase( p->xDel==sqlite3VdbeFrameMemDel );
      if( p->flags&(MEM_Agg|MEM_Dyn) ){
        sqlite3VdbeMemRelease(p);
      }else if( p->szMalloc ){
        sqlite3DbFreeNN(db, p->zMalloc);
        p->szMalloc = 0;
      }

      p->flags = MEM_Undefined;
    }while( (++p)<pEnd );
  }
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
jne 0x28fb17
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %rax
imulq $0x38, %rax, %r15
addq %rdi, %r15
movq 0x28(%rdi), %r14
cmpq $0x0, 0x2d0(%r14)
je 0x28fada
cmpl $0x0, 0x20(%rbx)
je 0x28facf
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x28facf
movq %r14, %rdi
callq 0x282904
addq $0x38, %rbx
cmpq %r15, %rbx
jb 0x28fab8
jmp 0x28fb12
testb $0x24, 0x9(%rbx)
je 0x28faea
movq %rbx, %rdi
callq 0x291775
jmp 0x28fb03
cmpl $0x0, 0x20(%rbx)
je 0x28fb03
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x282904
movl $0x0, 0x20(%rbx)
movw $0x80, 0x8(%rbx)
addq $0x38, %rbx
cmpq %r15, %rbx
jb 0x28fada
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: vdbeFreeOpArray
static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
  if( aOp ){
    Op *pOp;
    for(pOp=&aOp[nOp-1]; pOp>=aOp; pOp--){
      if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
      sqlite3DbFree(db, pOp->zComment);
#endif
    }
    sqlite3DbFreeNN(db, aOp);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x28fb68
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax,8), %r15
addq $-0x18, %r15
cmpq %rbx, %r15
jb 0x28fb58
movsbl 0x1(%r15), %esi
cmpl $-0x7, %esi
jg 0x28fb52
movq 0x10(%r15), %rdx
movq %r14, %rdi
callq 0x28fb69
addq $-0x18, %r15
jmp 0x28fb37
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
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: sqlite3VtabModuleUnref
SQLITE_PRIVATE void sqlite3VtabModuleUnref(sqlite3 *db, Module *pMod){
  assert( pMod->nRefModule>0 );
  pMod->nRefModule--;
  if( pMod->nRefModule==0 ){
    if( pMod->xDestroy ){
      pMod->xDestroy(pMod->pAux);
    }
    assert( pMod->pEpoTab==0 );
    sqlite3DbFree(db, pMod);
  }
}

// Assembly:
decl 0x10(%rsi)
je 0x28fc89
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x28fca2
movq 0x18(%rbx), %rdi
callq *%rax
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: sqlite3VdbeDelete
SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
  sqlite3 *db;

  assert( p!=0 );
  db = p->db;
  assert( sqlite3_mutex_held(db->mutex) );
  sqlite3VdbeClearObject(db, p);
  if( p->pPrev ){
    p->pPrev->pNext = p->pNext;
  }else{
    assert( db->pVdbe==p );
    db->pVdbe = p->pNext;
  }
  if( p->pNext ){
    p->pNext->pPrev = p->pPrev;
  }
  p->magic = VDBE_MAGIC_DEAD;
  p->db = 0;
  sqlite3DbFreeNN(db, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x272469
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x8(%r14), %rdx
leaq 0x10(%rax), %rsi
testq %rax, %rax
cmoveq %rdx, %rsi
movq %rcx, (%rsi)
testq %rcx, %rcx
je 0x28fd36
movq %rax, 0x8(%rcx)
movl $0x5606c3c8, 0x24(%rbx) # imm = 0x5606C3C8
movq $0x0, (%rbx)
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: apiOomError
SQLITE_PRIVATE void sqlite3OomClear(sqlite3 *db){
  if( db->mallocFailed && db->nVdbeExec==0 ){
    db->mallocFailed = 0;
    AtomicStore(&db->u1.isInterrupted, 0);
    assert( db->lookaside.bDisable>0 );
    EnableLookaside;
  }
}

// Assembly:
cmpb $0x0, 0x61(%rdi)
je 0x28fd8d
cmpl $0x0, 0xcc(%rdi)
jne 0x28fd8d
movb $0x0, 0x61(%rdi)
movl $0x0, 0x168(%rdi)
decl 0x170(%rdi)
je 0x28fd7f
xorl %eax, %eax
jmp 0x28fd86
movzwl 0x176(%rdi), %eax
movw %ax, 0x174(%rdi)
movl $0x7, 0x50(%rdi)
movl $0x7, %esi
jmp 0x284b1f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeTransferError
SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
  sqlite3 *db = p->db;
  int rc = p->rc;
  if( p->zErrMsg ){
    db->bBenignMalloc++;
    sqlite3BeginBenignMalloc();
    if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
    sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
    sqlite3EndBenignMalloc();
    db->bBenignMalloc--;
  }else if( db->pErr ){
    sqlite3ValueSetNull(db->pErr);
  }
  db->errCode = rc;
  return rc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x38(%rdi), %ebp
cmpq $0x0, 0xa8(%rdi)
je 0x2902bf
movq %rdi, %r14
incb 0x62(%rbx)
movq 0x22ebfa(%rip), %rax    # 0x4bee48
testq %rax, %rax
je 0x290255
callq *%rax
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
jne 0x290287
movl $0x38, %esi
movq %rbx, %rdi
callq 0x279b27
testq %rax, %rax
je 0x2902d8
movq %rax, %rdi
movw $0x1, 0x8(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x160(%rbx)
movq 0xa8(%r14), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x278594
movq 0x22eba5(%rip), %rax    # 0x4bee50
testq %rax, %rax
je 0x2902b2
callq *%rax
decb 0x62(%rbx)
movl %ebp, 0x50(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x2902b5
testb $0x24, 0x9(%rdi)
je 0x2902e5
callq 0x2917ab
jmp 0x2902b5
movq $0x0, 0x160(%rbx)
jmp 0x2902a4
movw $0x1, 0x8(%rdi)
jmp 0x2902b5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeEnter
SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
  int i;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  if( DbMaskAllZero(p->lockMask) ) return;  /* The common case */
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;
  for(i=0; i<nDb; i++){
    if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
      sqlite3BtreeEnter(aDb[i].pBt);
    }
  }
}

// Assembly:
movl 0xcc(%rdi), %eax
testl %eax, %eax
je 0x290337
movq (%rdi), %rdx
movslq 0x28(%rdx), %rcx
testq %rcx, %rcx
jle 0x290337
movq 0x20(%rdx), %rdx
addq $0x8, %rdx
xorl %esi, %esi
cmpq $0x1, %rsi
je 0x29032b
btl %esi, %eax
jae 0x29032b
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x29032b
movq (%rdi), %r8
movq 0x8(%rdi), %rdi
movq %r8, 0x8(%rdi)
incq %rsi
addq $0x20, %rdx
cmpq %rsi, %rcx
jne 0x29030d
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: closeCursorsInFrame
static void closeCursorsInFrame(Vdbe *p){
  if( p->apCsr ){
    int i;
    for(i=0; i<p->nCursor; i++){
      VdbeCursor *pC = p->apCsr[i];
      if( pC ){
        sqlite3VdbeFreeCursor(p, pC);
        p->apCsr[i] = 0;
      }
    }
  }
}

// Assembly:
cmpq $0x0, 0x78(%rdi)
je 0x290d4b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
testl %eax, %eax
jle 0x290d44
xorl %r14d, %r14d
movq 0x78(%rbx), %rcx
movq (%rcx,%r14,8), %rsi
testq %rsi, %rsi
je 0x290d39
movq %rbx, %rdi
callq 0x290dc1
movq 0x78(%rbx), %rax
movq $0x0, (%rax,%r14,8)
movl 0x2c(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x290d15
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: sqlite3VdbeDeleteAuxData
SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){
  while( *pp ){
    AuxData *pAux = *pp;
    if( (iOp<0)
     || (pAux->iAuxOp==iOp
          && pAux->iAuxArg>=0
          && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg))))
    ){
      testcase( pAux->iAuxArg==31 );
      if( pAux->xDeleteAux ){
        pAux->xDeleteAux(pAux->pAux);
      }
      *pp = pAux->pNextAux;
      sqlite3DbFree(db, pAux);
    }else{
      pp= &pAux->pNextAux;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x290db8
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testl %ebp, %ebp
js 0x290d8c
cmpl %ebp, (%r12)
jne 0x290d83
movl 0x4(%r12), %eax
testl %eax, %eax
js 0x290d83
cmpl $0x1f, %eax
ja 0x290d8c
btl %eax, %ebx
jae 0x290d8c
addq $0x18, %r12
movq %r12, %r15
jmp 0x290db0
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x290d9d
movq 0x8(%r12), %rdi
callq *%rax
movq 0x18(%r12), %rax
movq %rax, (%r15)
movq %r14, %rdi
movq %r12, %rsi
callq 0x282904
movq (%r15), %r12
testq %r12, %r12
jne 0x290d66
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: sqlite3VdbeFreeCursor
SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
  if( pCx==0 ){
    return;
  }
  assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
  switch( pCx->eCurType ){
    case CURTYPE_SORTER: {
      sqlite3VdbeSorterClose(p->db, pCx);
      break;
    }
    case CURTYPE_BTREE: {
      if( pCx->isEphemeral ){
        if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx);
        /* The pCx->pCursor will be close automatically, if it exists, by
        ** the call above. */
      }else{
        assert( pCx->uc.pCursor!=0 );
        sqlite3BtreeCloseCursor(pCx->uc.pCursor);
      }
      break;
    }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    case CURTYPE_VTAB: {
      sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur;
      const sqlite3_module *pModule = pVCur->pVtab->pModule;
      assert( pVCur->pVtab->nRef>0 );
      pVCur->pVtab->nRef--;
      pModule->xClose(pVCur);
      break;
    }
#endif
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x290e51
movq %rsi, %rbx
movzbl (%rsi), %eax
testl %eax, %eax
je 0x290e2d
cmpl $0x2, %eax
je 0x290e18
cmpl $0x1, %eax
jne 0x290e51
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x290e51
movq (%rdi), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x291022
movq 0x40(%r14), %rdi
callq 0x272c00
movq %r15, %rdi
movq %r14, %rsi
callq 0x282904
movq $0x0, 0x30(%rbx)
jmp 0x290e51
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
decl 0x8(%rax)
popq %rbx
popq %r14
popq %r15
jmpq *0x38(%rcx)
testb $0x1, 0x5(%rbx)
jne 0x290e41
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x290f87
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x290e51
popq %rbx
popq %r14
popq %r15
jmp 0x290e57
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: sqlite3BtreeCloseCursor
SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
  Btree *pBtree = pCur->pBtree;
  if( pBtree ){
    BtShared *pBt = pCur->pBt;
    sqlite3BtreeEnter(pBtree);
    assert( pBt->pCursor!=0 );
    if( pBt->pCursor==pCur ){
      pBt->pCursor = pCur->pNext;
    }else{
      BtCursor *pPrev = pBt->pCursor;
      do{
        if( pPrev->pNext==pCur ){
          pPrev->pNext = pCur->pNext;
          break;
        }
        pPrev = pPrev->pNext;
      }while( ALWAYS(pPrev) );
    }
    btreeReleaseAllCursorPages(pCur);
    unlockBtreeIfUnused(pBt);
    sqlite3_free(pCur->aOverflow);
    sqlite3_free(pCur->pKey);
    sqlite3BtreeLeave(pBtree);
    pCur->pBtree = 0;
  }
  return SQLITE_OK;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x291021
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%r14), %rax
cmpq %rdi, %rax
je 0x290fc6
movq 0x28(%rax), %rcx
cmpq %rbx, %rcx
je 0x290fcc
movq %rcx, %rax
testq %rcx, %rcx
jne 0x290fb3
jmp 0x290fd7
leaq 0x10(%r14), %rax
jmp 0x290fd0
addq $0x28, %rax
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x28e0af
cmpb $0x0, 0x24(%r14)
jne 0x291000
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x291000
movq $0x0, 0x18(%r14)
movq 0x70(%rax), %rdi
callq 0x28cfb5
movq 0x10(%rbx), %rdi
callq 0x272c00
movq 0x18(%rbx), %rdi
callq 0x272c00
movq $0x0, 0x8(%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: vdbeMergeEngineFree
static void vdbeMergeEngineFree(MergeEngine *pMerger){
  int i;
  if( pMerger ){
    for(i=0; i<pMerger->nTree; i++){
      vdbePmaReaderClear(&pMerger->aReadr[i]);
    }
  }
  sqlite3_free(pMerger);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x29123d
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x29120d
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
addq %r14, %rdi
callq 0x291243
incq %r15
movslq (%rbx), %rax
addq $0x50, %r14
cmpq %rax, %r15
jl 0x2911f2
cmpl $0x0, 0x22a44c(%rip)    # 0x4bb660
je 0x29122f
movq %rbx, %rdi
callq *0x22a479(%rip)         # 0x4bb698
cltq
subq %rax, 0x22d8d0(%rip)    # 0x4beaf8
decq 0x22d911(%rip)          # 0x4beb40
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x22a44b(%rip)         # 0x4bb688
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: vdbePmaReaderClear
static void vdbePmaReaderClear(PmaReader *pReadr){
  sqlite3_free(pReadr->aAlloc);
  sqlite3_free(pReadr->aBuffer);
  if( pReadr->aMap ) sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap);
  vdbeIncrFree(pReadr->pIncr);
  memset(pReadr, 0, sizeof(PmaReader));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x272c00
movq 0x30(%rbx), %rdi
callq 0x272c00
movq 0x40(%rbx), %rdx
testq %rdx, %rdx
je 0x291271
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x90(%rax)
movq 0x48(%rbx), %rdi
callq 0x291292
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeIncrFree
static void vdbeIncrFree(IncrMerger *pIncr){
  if( pIncr ){
#if SQLITE_MAX_WORKER_THREADS>0
    if( pIncr->bUseThread ){
      vdbeSorterJoinThread(pIncr->pTask);
      if( pIncr->aFile[0].pFd ) sqlite3OsCloseFree(pIncr->aFile[0].pFd);
      if( pIncr->aFile[1].pFd ) sqlite3OsCloseFree(pIncr->aFile[1].pFd);
    }
#endif
    vdbeMergeEngineFree(pIncr->pMerger);
    sqlite3_free(pIncr);
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2912d0
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2911da
cmpl $0x0, 0x22a3b5(%rip)    # 0x4bb660
je 0x2912c6
movq %rbx, %rdi
callq *0x22a3e2(%rip)         # 0x4bb698
cltq
subq %rax, 0x22d839(%rip)    # 0x4beaf8
decq 0x22d87a(%rip)          # 0x4beb40
movq %rbx, %rdi
popq %rbx
jmpq *0x22a3b8(%rip)         # 0x4bb688
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: callFinaliser
static void callFinaliser(sqlite3 *db, int offset){
  int i;
  if( db->aVTrans ){
    VTable **aVTrans = db->aVTrans;
    db->aVTrans = 0;
    for(i=0; i<db->nVTrans; i++){
      VTable *pVTab = aVTrans[i];
      sqlite3_vtab *p = pVTab->pVtab;
      if( p ){
        int (*x)(sqlite3_vtab *);
        x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
        if( x ) x(p);
      }
      pVTab->iSavepoint = 0;
      sqlite3VtabUnlock(pVTab);
    }
    sqlite3DbFree(db, aVTrans);
    db->nVTrans = 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x210(%rdi), %r14
testq %r14, %r14
je 0x291353
movq %rdi, %rbx
movq $0x0, 0x210(%rdi)
cmpl $0x0, 0x1ec(%rdi)
jle 0x29133e
movl %esi, %r12d
xorl %r13d, %r13d
movq (%r14,%r13,8), %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x29131f
movq (%rdi), %rax
movq (%rax,%r12), %rax
testq %rax, %rax
je 0x29131f
callq *%rax
movl $0x0, 0x20(%r15)
movq %r15, %rdi
callq 0x28fc3f
incq %r13
movslq 0x1ec(%rbx), %rax
cmpq %rax, %r13
jl 0x291304
movq %rbx, %rdi
movq %r14, %rsi
callq 0x282904
movl $0x0, 0x1ec(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeError
SQLITE_PRIVATE void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){
  va_list ap;
  sqlite3DbFree(p->db, p->zErrMsg);
  va_start(ap, zFormat);
  p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap);
  va_end(ap);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2913bc
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 0xa8(%rdi), %rsi
testq %rsi, %rsi
je 0x2913d0
movq (%rbx), %rdi
callq 0x282904
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x284ab7
movq %rax, 0xa8(%rbx)
addq $0xd8, %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: sqlite3OsOpenMalloc
SQLITE_PRIVATE int sqlite3OsOpenMalloc(
  sqlite3_vfs *pVfs,
  const char *zFile,
  sqlite3_file **ppFile,
  int flags,
  int *pOutFlags
){
  int rc;
  sqlite3_file *pFile;
  pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
  if( pFile ){
    rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
    if( rc!=SQLITE_OK ){
      sqlite3_free(pFile);
    }else{
      *ppFile = pFile;
    }
  }else{
    rc = SQLITE_NOMEM_BKPT;
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, %r12d
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r13
movslq 0x4(%rdi), %r15
movq %r15, %rdi
callq 0x272ae6
testq %rax, %rax
je 0x2914ac
movq %rax, %rbx
movq %rbp, 0x8(%rsp)
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x173a0
andl $0x1087f7f, %r12d       # imm = 0x1087F7F
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r12d, %ecx
movq 0x10(%rsp), %r8
callq *0x28(%r13)
testl %eax, %eax
je 0x2914b3
movl %eax, %r15d
cmpl $0x0, 0x22a1dd(%rip)    # 0x4bb660
je 0x29149e
movq %rbx, %rdi
callq *0x22a20a(%rip)         # 0x4bb698
cltq
subq %rax, 0x22d661(%rip)    # 0x4beaf8
decq 0x22d6a2(%rip)          # 0x4beb40
movq %rbx, %rdi
callq *0x22a1e1(%rip)         # 0x4bb688
movl %r15d, %ebp
jmp 0x2914bb
movl $0x7, %ebp
jmp 0x2914bb
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
movl %ebp, %eax
addq $0x18, %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: sqlite3VtabImportErrmsg
SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){
  if( pVtab->zErrMsg ){
    sqlite3 *db = p->db;
    sqlite3DbFree(db, p->zErrMsg);
    p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
    sqlite3_free(pVtab->zErrMsg);
    pVtab->zErrMsg = 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x29151e
movq %rdi, %r14
movq (%rdi), %r15
movq 0xa8(%rdi), %rax
testq %rax, %rax
je 0x2914fe
movq %r15, %rdi
movq %rax, %rsi
callq 0x282904
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x279928
movq %rax, 0xa8(%r14)
movq 0x10(%rbx), %rdi
callq 0x272c00
movq $0x0, 0x10(%rbx)
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: vdbeCloseStatement
static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){
  sqlite3 *const db = p->db;
  int rc = SQLITE_OK;
  int i;
  const int iSavepoint = p->iStatement-1;

  assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
  assert( db->nStatement>0 );
  assert( p->iStatement==(db->nStatement+db->nSavepoint) );

  for(i=0; i<db->nDb; i++){
    int rc2 = SQLITE_OK;
    Btree *pBt = db->aDb[i].pBt;
    if( pBt ){
      if( eOp==SAVEPOINT_ROLLBACK ){
        rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
      }
      if( rc2==SQLITE_OK ){
        rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
      }
      if( rc==SQLITE_OK ){
        rc = rc2;
      }
    }
  }
  db->nStatement--;
  p->iStatement = 0;

  if( rc==SQLITE_OK ){
    if( eOp==SAVEPOINT_ROLLBACK ){
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
    }
    if( rc==SQLITE_OK ){
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
    }
  }

  /* If the statement transaction is being rolled back, also restore the
  ** database handles deferred constraint counter to the value it had when
  ** the statement transaction was opened.  */
  if( eOp==SAVEPOINT_ROLLBACK ){
    db->nDeferredCons = p->nStmtDefCons;
    db->nDeferredImmCons = p->nStmtDefImmCons;
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movq (%rdi), %rbx
movl 0x40(%rdi), %r15d
decl %r15d
movl 0x28(%rbx), %eax
testl %eax, %eax
jle 0x2915c5
movq %r14, 0x10(%rsp)
xorl %r14d, %r14d
movl $0x8, %ebp
xorl %r12d, %r12d
movq 0x20(%rbx), %rcx
movq (%rcx,%rbp), %r13
testq %r13, %r13
je 0x29159c
cmpl $0x2, 0xc(%rsp)
jne 0x291582
movq %r13, %rdi
movl $0x2, %esi
movl %r15d, %edx
callq 0x291629
testl %eax, %eax
jne 0x291592
movq %r13, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x291629
testl %r12d, %r12d
cmovel %eax, %r12d
movl 0x28(%rbx), %eax
incq %r14
movslq %eax, %rcx
addq $0x20, %rbp
cmpq %rcx, %r14
jl 0x29155a
decl 0x2bc(%rbx)
movq 0x10(%rsp), %r14
movl $0x0, 0x40(%r14)
testl %r12d, %r12d
jne 0x291604
jmp 0x2915d3
decl 0x2bc(%rbx)
movl $0x0, 0x40(%r14)
cmpl $0x2, 0xc(%rsp)
jne 0x2915f1
movq %rbx, %rdi
movl $0x2, %esi
movl %r15d, %edx
callq 0x2916ae
movl %eax, %r12d
testl %eax, %eax
jne 0x29160b
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x2916ae
movl %eax, %r12d
cmpl $0x2, 0xc(%rsp)
jne 0x291617
movups 0x58(%r14), %xmm0
movups %xmm0, 0x2c0(%rbx)
movl %r12d, %eax
addq $0x18, %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: sqlite3BtreeSavepoint
SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
  int rc = SQLITE_OK;
  if( p && p->inTrans==TRANS_WRITE ){
    BtShared *pBt = p->pBt;
    assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
    assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
    sqlite3BtreeEnter(p);
    if( op==SAVEPOINT_ROLLBACK ){
      rc = saveAllCursors(pBt, 0, 0);
    }
    if( rc==SQLITE_OK ){
      rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
    }
    if( rc==SQLITE_OK ){
      if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
        pBt->nPage = 0;
      }
      rc = newDatabase(pBt);
      btreeSetNPage(pBt, pBt->pPage1);

      /* pBt->nPage might be zero if the database was corrupt when
      ** the transaction was started. Otherwise, it must be at least 1.  */
      assert( CORRUPT_DB || pBt->nPage>0 );
    }
    sqlite3BtreeLeave(p);
  }
  return rc;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x2916ad
cmpb $0x2, 0x10(%rdi)
jne 0x2916ad
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq (%rdi), %rax
movq 0x8(%rdi), %rbx
movq %rax, 0x8(%rbx)
cmpl $0x2, %esi
jne 0x291665
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x291665
xorl %esi, %esi
xorl %edx, %edx
callq 0x28e021
testl %eax, %eax
jne 0x2916a9
movq (%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x2899b6
testl %eax, %eax
jne 0x2916a9
testl %ebp, %ebp
jns 0x291687
testb $0x10, 0x28(%rbx)
je 0x291687
movl $0x0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x28c978
movq 0x18(%rbx), %rcx
movq 0x50(%rcx), %rcx
movl 0x1c(%rcx), %ecx
bswapl %ecx
testl %ecx, %ecx
jne 0x2916a6
movq (%rbx), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x40(%rbx)
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: vdbeMemClear
static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
  if( VdbeMemDynamic(p) ){
    vdbeMemClearExternAndSetNull(p);
  }
  if( p->szMalloc ){
    sqlite3DbFreeNN(p->db, p->zMalloc);
    p->szMalloc = 0;
  }
  p->z = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x24, 0x9(%rdi)
je 0x291787
movq %rbx, %rdi
callq 0x2917ab
cmpl $0x0, 0x20(%rbx)
je 0x2917a1
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0x282904
movl $0x0, 0x20(%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeMemClearExternAndSetNull
static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
  assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
  assert( VdbeMemDynamic(p) );
  if( p->flags&MEM_Agg ){
    sqlite3VdbeMemFinalize(p, p->u.pDef);
    assert( (p->flags & MEM_Agg)==0 );
    testcase( p->flags & MEM_Dyn );
  }
  if( p->flags&MEM_Dyn ){
    assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
    p->xDel((void *)p->z);
  }
  p->flags = MEM_Null;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
btl $0xd, %eax
jae 0x2917c7
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x2917dc
movzwl 0x8(%rbx), %eax
btl $0xa, %eax
jae 0x2917d4
movq 0x10(%rbx), %rdi
callq *0x30(%rbx)
movw $0x1, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemFinalize
SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
  sqlite3_context ctx;
  Mem t;
  assert( pFunc!=0 );
  assert( pFunc->xFinalize!=0 );
  assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  memset(&ctx, 0, sizeof(ctx));
  memset(&t, 0, sizeof(t));
  t.flags = MEM_Null;
  t.db = pMem->db;
  ctx.pOut = &t;
  ctx.pMem = pMem;
  ctx.pFunc = pFunc;
  pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
  assert( (pMem->flags & MEM_Dyn)==0 );
  if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
  memcpy(pMem, &t, sizeof(t));
  return ctx.isError;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %rdi
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movw $0x1, 0x8(%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x28(%rax)
movq %rax, (%rdi)
movq %rbx, 0x10(%rdi)
movq %rsi, 0x8(%rdi)
callq *0x20(%rsi)
cmpl $0x0, 0x20(%rbx)
jle 0x291839
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0x282904
movq 0x30(%rsp), %rax
movq %rax, 0x30(%rbx)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl 0x5c(%rsp), %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DbReallocOrFree
SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){
  void *pNew;
  pNew = sqlite3DbRealloc(db, p, n);
  if( !pNew ){
    sqlite3DbFree(db, p);
  }
  return pNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2829e5
movq %rax, %r15
testq %rax, %rax
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x291a00
movq %r14, %rdi
movq %rbx, %rsi
callq 0x282904
movq %r15, %rax
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: valueToText
static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
  assert( pVal!=0 );
  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( !sqlite3VdbeMemIsRowSet(pVal) );
  assert( (pVal->flags & (MEM_Null))==0 );
  if( pVal->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(pVal) ) return 0;
    pVal->flags |= MEM_Str;
    if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
      sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
    }
    if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
      assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
      if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
        return 0;
      }
    }
    sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
  }else{
    sqlite3VdbeMemStringify(pVal, enc, 0);
    assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
  }
  assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
              || pVal->db->mallocFailed );
  if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
    assert( sqlite3VdbeMemValidStrRep(pVal) );
    return pVal->z;
  }else{
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
movzwl %ax, %ecx
testb $0x12, %cl
je 0x291a99
btl $0xe, %ecx
jae 0x291a4a
movq %rbx, %rdi
callq 0x2781c2
testl %eax, %eax
jne 0x291ab7
movzwl 0x8(%rbx), %eax
orl $0x2, %eax
movw %ax, 0x8(%rbx)
movzbl 0xa(%rbx), %eax
movzbl %bpl, %esi
andl $-0x9, %esi
cmpl %eax, %esi
je 0x291a68
movq %rbx, %rdi
callq 0x291bc7
testb $0x8, %bpl
je 0x291a80
testb $0x1, 0x10(%rbx)
je 0x291a80
movq %rbx, %rdi
callq 0x27840a
testl %eax, %eax
jne 0x291ab7
movzwl 0x8(%rbx), %eax
andl $0x202, %eax            # imm = 0x202
cmpw $0x2, %ax
jne 0x291aa7
movq %rbx, %rdi
callq 0x29214c
jmp 0x291aa7
movzbl %bpl, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x291ac0
andb $-0x9, %bpl
cmpb %bpl, 0xa(%rbx)
jne 0x291ab7
movq 0x10(%rbx), %rax
jmp 0x291ab9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq