LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3UnlinkAndDeleteTrigger
SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
  Trigger *pTrigger;
  Hash *pHash;

  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  pHash = &(db->aDb[iDb].pSchema->trigHash);
  pTrigger = sqlite3HashInsert(pHash, zName, 0);
  if( ALWAYS(pTrigger) ){
    if( pTrigger->pSchema==pTrigger->pTabSchema ){
      Table *pTab = tableOfTrigger(pTrigger);
      if( pTab ){
        Trigger **pp;
        for(pp=&pTab->pTrigger; *pp; pp=&((*pp)->pNext)){
          if( *pp==pTrigger ){
            *pp = (*pp)->pNext;
            break;
          }
        }
      }
    }
    sqlite3DeleteTrigger(db, pTrigger);
    db->mDbFlags |= DBFLAG_SchemaChange;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x40ada0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3fe680
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x3fe666
movq -0x20(%rbp), %rdi
callq 0x40cd30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3fe664
movq -0x30(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3fe662
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x3fe64f
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3fe662
jmp 0x3fe651
movq -0x38(%rbp), %rax
movq (%rax), %rax
addq $0x40, %rax
movq %rax, -0x38(%rbp)
jmp 0x3fe624
jmp 0x3fe664
jmp 0x3fe666
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3bfea0
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x2c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemSetRowSet
SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem *pMem){
  sqlite3 *db = pMem->db;
  RowSet *p;
  assert( db!=0 );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  sqlite3VdbeMemRelease(pMem);
  p = sqlite3RowSetInit(db);
  if( p==0 ) return SQLITE_NOMEM;
  pMem->z = (char*)p;
  pMem->flags = MEM_Blob|MEM_Dyn;
  pMem->xDel = sqlite3RowSetDelete;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c76d0
movq -0x18(%rbp), %rdi
callq 0x40dce0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3fec2e
movl $0x7, -0x4(%rbp)
jmp 0x3fec5a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movw $0x410, 0x8(%rax)       # imm = 0x410
movq -0x10(%rbp), %rax
leaq 0xf151(%rip), %rcx      # 0x40dda0
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RowSetInsert
SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){
  struct RowSetEntry *pEntry;  /* The new entry */
  struct RowSetEntry *pLast;   /* The last prior entry */

  /* This routine is never called after sqlite3RowSetNext() */
  assert( p!=0 && (p->rsFlags & ROWSET_NEXT)==0 );

  pEntry = rowSetEntryAlloc(p);
  if( pEntry==0 ) return;
  pEntry->v = rowid;
  pEntry->pRight = 0;
  pLast = p->pLast;
  if( pLast ){
    if( rowid<=pLast->v ){  /*OPTIMIZATION-IF-FALSE*/
      /* Avoid unnecessary sorts by preserving the ROWSET_SORTED flags
      ** where possible */
      p->rsFlags &= ~ROWSET_SORTED;
    }
    pLast->pRight = pEntry;
  }else{
    p->pEntry = pEntry;
  }
  p->pLast = pEntry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40de70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3fec96
jmp 0x3fed02
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3fecea
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jg 0x3fecdc
movq -0x8(%rbp), %rax
movzwl 0x32(%rax), %ecx
andl $-0x2, %ecx
movw %cx, 0x32(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3fecf6
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RowSetNext
SQLITE_PRIVATE int sqlite3RowSetNext(RowSet *p, i64 *pRowid){
  assert( p!=0 );
  assert( p->pForest==0 );  /* Cannot be used with sqlite3RowSetText() */

  /* Merge the forest into a single sorted list on first call */
  if( (p->rsFlags & ROWSET_NEXT)==0 ){  /*OPTIMIZATION-IF-FALSE*/
    if( (p->rsFlags & ROWSET_SORTED)==0 ){  /*OPTIMIZATION-IF-FALSE*/
      p->pEntry = rowSetEntrySort(p->pEntry);
    }
    p->rsFlags |= ROWSET_SORTED|ROWSET_NEXT;
  }

  /* Return the next entry on the list */
  if( p->pEntry ){
    *pRowid = p->pEntry->v;
    p->pEntry = p->pEntry->pRight;
    if( p->pEntry==0 ){ /*OPTIMIZATION-IF-TRUE*/
      /* Free memory immediately, rather than waiting on sqlite3_finalize() */
      sqlite3RowSetClear(p);
    }
    return 1;
  }else{
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x32(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x3fed67
movq -0x10(%rbp), %rax
movzwl 0x32(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3fed58
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40df20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movzwl 0x32(%rax), %ecx
orl $0x3, %ecx
movw %cx, 0x32(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3fedb5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3fedac
movq -0x10(%rbp), %rdi
callq 0x40ddd0
movl $0x1, -0x4(%rbp)
jmp 0x3fedbc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeFrameMemDel
SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void *pArg){
  VdbeFrame *pFrame = (VdbeFrame*)pArg;
  assert( sqlite3VdbeFrameIsValid(pFrame) );
  pFrame->pParent = pFrame->v->pDelFrame;
  pFrame->v->pDelFrame = pFrame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x108(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x108(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemInit
SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
  assert( (flags & ~MEM_TypeMask)==0 );
  pMem->flags = flags;
  pMem->db = db;
  pMem->szMalloc = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movw -0x12(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemAggValue
SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){
  sqlite3_context ctx;
  assert( pFunc!=0 );
  assert( pFunc->xValue!=0 );
  assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
  assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) );
  memset(&ctx, 0, sizeof(ctx));
  sqlite3VdbeMemSetNull(pOut);
  ctx.pOut = pOut;
  ctx.pMem = pAccum;
  ctx.pFunc = pFunc;
  pFunc->xValue(&ctx);
  return ctx.isError;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x19360
movq -0x10(%rbp), %rdi
callq 0x3c8550
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
leaq -0x50(%rbp), %rdi
callq *0x28(%rax)
movl -0x2c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PagerCloseWal
SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){
  int rc = SQLITE_OK;

  assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );

  /* If the log file is not already open, but does exist in the file-system,
  ** it may need to be checkpointed before the connection can switch to
  ** rollback mode. Open it now so this can happen.
  */
  if( !pPager->pWal ){
    int logexists = 0;
    rc = pagerLockDb(pPager, SHARED_LOCK);
    if( rc==SQLITE_OK ){
      rc = sqlite3OsAccess(
          pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
      );
    }
    if( rc==SQLITE_OK && logexists ){
      rc = pagerOpenWal(pPager);
    }
  }

  /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
  ** the database file, the log and log-summary files will be deleted.
  */
  if( rc==SQLITE_OK && pPager->pWal ){
    rc = pagerExclusiveLock(pPager);
    if( rc==SQLITE_OK ){
      rc = sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags,
                           pPager->pageSize, (u8*)pPager->pTmpSpace);
      pPager->pWal = 0;
      pagerFixMaplimit(pPager);
      if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x120(%rax)
jne 0x3ff17d
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3e0740
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3ff163
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rsi
xorl %edx, %edx
leaq -0x18(%rbp), %rcx
callq 0x3e36f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3ff17b
cmpl $0x0, -0x18(%rbp)
je 0x3ff17b
movq -0x8(%rbp), %rdi
callq 0x3e76b0
movl %eax, -0x14(%rbp)
jmp 0x3ff17d
cmpl $0x0, -0x14(%rbp)
jne 0x3ff219
movq -0x8(%rbp), %rax
cmpq $0x0, 0x120(%rax)
je 0x3ff219
movq -0x8(%rbp), %rdi
callq 0x3e7740
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3ff217
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movzbl 0xf(%rax), %edx
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x110(%rax), %r8
callq 0x3e5230
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x120(%rax)
movq -0x8(%rbp), %rdi
callq 0x3e4f50
cmpl $0x0, -0x14(%rbp)
je 0x3ff215
movq -0x8(%rbp), %rax
cmpb $0x0, 0x8(%rax)
jne 0x3ff215
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3e3fb0
jmp 0x3ff217
jmp 0x3ff219
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VtabBegin
SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){
  int rc = SQLITE_OK;
  const sqlite3_module *pModule;

  /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
  ** than zero, then this function is being called from within a
  ** virtual module xSync() callback. It is illegal to write to
  ** virtual module tables in this case, so return SQLITE_LOCKED.
  */
  if( sqlite3VtabInSync(db) ){
    return SQLITE_LOCKED;
  }
  if( !pVTab ){
    return SQLITE_OK;
  }
  pModule = pVTab->pVtab->pModule;

  if( pModule->xBegin ){
    int i;

    /* If pVtab is already in the aVTrans array, return early */
    for(i=0; i<db->nVTrans; i++){
      if( db->aVTrans[i]==pVTab ){
        return SQLITE_OK;
      }
    }

    /* Invoke the xBegin method. If successful, add the vtab to the
    ** sqlite3.aVTrans[] array. */
    rc = growVTrans(db);
    if( rc==SQLITE_OK ){
      rc = pModule->xBegin(pVTab->pVtab);
      if( rc==SQLITE_OK ){
        int iSvpt = db->nStatement + db->nSavepoint;
        addToVTrans(db, pVTab);
        if( iSvpt && pModule->xSavepoint ){
          pVTab->iSavepoint = iSvpt;
          rc = pModule->xSavepoint(pVTab->pVtab, iSvpt-1);
        }
      }
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1ec(%rax)
jle 0x3ffc8e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x210(%rax)
jne 0x3ffc8e
movl $0x6, -0x4(%rbp)
jmp 0x3ffda0
cmpq $0x0, -0x18(%rbp)
jne 0x3ffca1
movl $0x0, -0x4(%rbp)
jmp 0x3ffda0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x3ffd9a
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1ec(%rcx), %eax
jge 0x3ffd07
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x3ffcfa
movl $0x0, -0x4(%rbp)
jmp 0x3ffda0
jmp 0x3ffcfc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3ffcc6
movq -0x10(%rbp), %rdi
callq 0x40ead0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3ffd98
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x3ffd96
movq -0x10(%rbp), %rax
movl 0x2bc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x2b8(%rcx), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x40eb80
cmpl $0x0, -0x30(%rbp)
je 0x3ffd94
movq -0x28(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x3ffd94
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0xa0(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl -0x30(%rbp), %esi
subl $0x1, %esi
callq *%rax
movl %eax, -0x1c(%rbp)
jmp 0x3ffd96
jmp 0x3ffd98
jmp 0x3ffd9a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VtabCallDestroy
SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
  int rc = SQLITE_OK;
  Table *pTab;

  pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zDbSName);
  if( pTab!=0 && ALWAYS(pTab->pVTable!=0) ){
    VTable *p;
    int (*xDestroy)(sqlite3_vtab *);
    for(p=pTab->pVTable; p; p=p->pNext){
      assert( p->pVtab );
      if( p->pVtab->nRef>0 ){
        return SQLITE_LOCKED;
      }
    }
    p = vtabDisconnectAll(db, pTab);
    xDestroy = p->pMod->pModule->xDestroy;
    if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect;
    assert( xDestroy!=0 );
    pTab->nTabRef++;
    rc = xDestroy(p->pVtab);
    /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
    if( rc==SQLITE_OK ){
      assert( pTab->pVTable==p && p->pNext==0 );
      p->pVtab = 0;
      pTab->pVTable = 0;
      sqlite3VtabUnlock(p);
    }
    sqlite3DeleteTable(db, pTab);
  }

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
callq 0x3d38b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x400018
movq -0x30(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x400018
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3fff88
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x8(%rax)
jle 0x3fff78
movl $0x6, -0x4(%rbp)
jmp 0x40001e
jmp 0x3fff7a
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3fff57
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x40f1b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3fffc6
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x40000b
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x38(%rbp), %rdi
callq 0x3eb660
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3bff20
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeMaxPageCount
SQLITE_PRIVATE Pgno sqlite3BtreeMaxPageCount(Btree *p, Pgno mxPage){
  Pgno n;
  sqlite3BtreeEnter(p);
  n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
  sqlite3BtreeLeave(p);
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c5aa0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x40f260
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: computeNumericType
static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
  int rc;
  sqlite3_int64 ix;
  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
  assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
  ExpandBlob(pMem);
  rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
  if( rc<=0 ){
    if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
      pMem->u.i = ix;
      return MEM_Int;
    }else{
      return MEM_Real;
    }
  }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
    pMem->u.i = ix;
    return MEM_Int;
  }
  return MEM_Real;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x400109
movq -0x10(%rbp), %rdi
callq 0x3c77c0
jmp 0x40010b
jmp 0x40010b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %ecx
callq 0x3ef260
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x40017a
cmpl $0x0, -0x14(%rbp)
jne 0x400172
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
leaq -0x20(%rbp), %rsi
movzbl 0xa(%rax), %ecx
callq 0x3efb50
cmpl $0x1, %eax
jg 0x400172
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movw $0x4, -0x2(%rbp)
jmp 0x4001c0
movw $0x8, -0x2(%rbp)
jmp 0x4001c0
cmpl $0x1, -0x14(%rbp)
jne 0x4001b8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
leaq -0x20(%rbp), %rsi
movzbl 0xa(%rax), %ecx
callq 0x3efb50
cmpl $0x0, %eax
jne 0x4001b8
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movw $0x4, -0x2(%rbp)
jmp 0x4001c0
jmp 0x4001ba
movw $0x8, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeIntegerAffinity
SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
  i64 ix;
  assert( pMem->flags & MEM_Real );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );

  ix = doubleToInt64(pMem->u.r);

  /* Only mark the value as an integer if
  **
  **    (1) the round-trip conversion real->int->real is a no-op, and
  **    (2) The integer is neither the largest nor the smallest
  **        possible integer (ticket #3922)
  **
  ** The second and third terms in the following conditional enforces
  ** the second condition under the assumption that addition overflow causes
  ** values to wrap around.
  */
  if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){
    pMem->u.i = ix;
    MemSetTypeFlag(pMem, MEM_Int);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x3efab0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x400249
jp 0x400249
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x10(%rbp)
jle 0x400249
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
jge 0x400249
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0xffff3e40, %eax       # imm = 0xFFFF3E40
orl $0x4, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemNumerify
SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
  testcase( pMem->flags & MEM_Int );
  testcase( pMem->flags & MEM_Real );
  testcase( pMem->flags & MEM_IntReal );
  testcase( pMem->flags & MEM_Null );
  if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){
    int rc;
    sqlite3_int64 ix;
    assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
    assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
    rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
    if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1)
     || sqlite3RealSameAsInt(pMem->u.r, (ix = (i64)pMem->u.r))
    ){
      pMem->u.i = ix;
      MemSetTypeFlag(pMem, MEM_Int);
    }else{
      MemSetTypeFlag(pMem, MEM_Real);
    }
  }
  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 );
  pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x2d, %eax
cmpl $0x0, %eax
jne 0x400358
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x8(%rbp), %rax
movzbl 0xa(%rax), %ecx
callq 0x3ef260
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x4002cf
cmpl $0x1, -0xc(%rbp)
jne 0x4002f4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x8(%rbp), %rax
leaq -0x18(%rbp), %rsi
movzbl 0xa(%rax), %ecx
callq 0x3efb50
cmpl $0x1, %eax
jle 0x400313
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
cvttsd2si (%rax), %rdi
movq %rdi, -0x18(%rbp)
callq 0x400380
cmpl $0x0, %eax
je 0x40033b
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0xffff3e40, %eax       # imm = 0xFFFF3E40
orl $0x4, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
jmp 0x400356
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0xffff3e40, %eax       # imm = 0xFFFF3E40
orl $0x8, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
jmp 0x400358
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %ecx
andl $0xffffbfed, %ecx       # imm = 0xFFFFBFED
movw %cx, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RealSameAsInt
SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){
  double r2 = (double)i;
  return r1==0.0
      || (memcmp(&r1, &r2, sizeof(r1))==0
          && i >= -2251799813685248LL && i < 2251799813685248LL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
cvtsi2sdq -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movb $0x1, %al
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jne 0x4003af
jp 0x4003af
jmp 0x4003f9
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
setne %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x4003f3
xorl %eax, %eax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, -0x10(%rbp)
movb %al, -0x1a(%rbp)
jl 0x4003f3
movabsq $0x8000000000000, %rax  # imm = 0x8000000000000
cmpq %rax, -0x10(%rbp)
setl %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IntFloatCompare
static int sqlite3IntFloatCompare(i64 i, double r){
  if( sizeof(LONGDOUBLE_TYPE)>8 ){
    LONGDOUBLE_TYPE x = (LONGDOUBLE_TYPE)i;
    if( x<r ) return -1;
    if( x>r ) return +1;
    return 0;
  }else{
    i64 y;
    double s;
    if( r<-9223372036854775808.0 ) return +1;
    if( r>=9223372036854775808.0 ) return -1;
    y = (i64)r;
    if( i<y ) return -1;
    if( i>y ) return +1;
    s = (double)i;
    if( s<r ) return -1;
    if( s>r ) return +1;
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
fildll -0x38(%rbp)
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
fldl -0x18(%rbp)
fucompi %st(1), %st
fstp %st(0)
jbe 0x400442
jmp 0x400439
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x400462
fldt -0x30(%rbp)
fldl -0x18(%rbp)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jbe 0x40045b
jmp 0x400452
movl $0x1, -0x4(%rbp)
jmp 0x400462
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeCompareMemString
static int vdbeCompareMemString(
  const Mem *pMem1,
  const Mem *pMem2,
  const CollSeq *pColl,
  u8 *prcErr                      /* If an OOM occurs, set to SQLITE_NOMEM */
){
  if( pMem1->enc==pColl->enc ){
    /* The strings are already in the correct encoding.  Call the
     ** comparison function directly */
    return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
  }else{
    int rc;
    const void *v1, *v2;
    Mem c1;
    Mem c2;
    sqlite3VdbeMemInit(&c1, pMem1->db, MEM_Null);
    sqlite3VdbeMemInit(&c2, pMem1->db, MEM_Null);
    sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
    sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
    v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
    v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
    if( (v1==0 || v2==0) ){
      if( prcErr ) *prcErr = SQLITE_NOMEM_BKPT;
      rc = 0;
    }else{
      rc = pColl->xCmp(pColl->pUser, c1.n, v1, c2.n, v2);
    }
    sqlite3VdbeMemRelease(&c1);
    sqlite3VdbeMemRelease(&c2);
    return rc;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xa(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x4004d7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %esi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x18(%rbp), %r8
movq 0x10(%r8), %r8
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x4005c0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x78(%rbp), %rdi
movl $0x1, %edx
callq 0x3ff010
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0xb0(%rbp), %rdi
movl $0x1, %edx
callq 0x3ff010
movq -0x10(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movl $0x1000, %edx           # imm = 0x1000
callq 0x3f9b50
movq -0x18(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movl $0x1000, %edx           # imm = 0x1000
callq 0x3f9b50
movq -0x20(%rbp), %rax
leaq -0x78(%rbp), %rdi
movzbl 0x8(%rax), %esi
callq 0x3c7bd0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
leaq -0xb0(%rbp), %rdi
movzbl 0x8(%rax), %esi
callq 0x3c7bd0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x400568
cmpq $0x0, -0x40(%rbp)
jne 0x40057f
cmpq $0x0, -0x28(%rbp)
je 0x400576
movq -0x28(%rbp), %rax
movb $0x7, (%rax)
movl $0x0, -0x2c(%rbp)
jmp 0x4005a5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl -0x6c(%rbp), %esi
movq -0x38(%rbp), %rdx
movl -0xa4(%rbp), %ecx
movq -0x40(%rbp), %r8
callq *%rax
movl %eax, -0x2c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3c76d0
leaq -0xb0(%rbp), %rdi
callq 0x3c76d0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BlobCompare
int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){
  int c;
  int n1 = pB1->n;
  int n2 = pB2->n;

  /* It is possible to have a Blob value that has some non-zero content
  ** followed by zero content.  But that only comes up for Blobs formed
  ** by the OP_MakeRecord opcode, and such Blobs never get passed into
  ** sqlite3MemCompare(). */
  assert( (pB1->flags & MEM_Zero)==0 || n1==0 );
  assert( (pB2->flags & MEM_Zero)==0 || n2==0 );

  if( (pB1->flags|pB2->flags) & MEM_Zero ){
    if( pB1->flags & pB2->flags & MEM_Zero ){
      return pB1->u.nZero - pB2->u.nZero;
    }else if( pB1->flags & MEM_Zero ){
      if( !isAllZero(pB2->z, pB2->n) ) return -1;
      return pB1->u.nZero - n2;
    }else{
      if( !isAllZero(pB1->z, pB1->n) ) return +1;
      return n1 - pB2->u.nZero;
    }
  }
  c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1);
  if( c ) return c;
  return n1 - n2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
orl %ecx, %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x4006bc
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
andl %ecx, %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x400644
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x400717
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x40068c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x400720
cmpl $0x0, %eax
jne 0x40067b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x400717
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x400717
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x400720
cmpl $0x0, %eax
jne 0x4006ae
movl $0x1, -0x4(%rbp)
jmp 0x400717
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x400717
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x4006e4
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x4006ea
movl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %eax
movslq %eax, %rdx
callq 0x192c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x40070e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x400717
movl -0x20(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: isAllZero
static int isAllZero(const char *z, int n){
  int i;
  for(i=0; i<n; i++){
    if( z[i] ) return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x40075e
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x400751
movl $0x0, -0x4(%rbp)
jmp 0x400765
jmp 0x400753
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x400732
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: handleMovedCursor
static int SQLITE_NOINLINE handleMovedCursor(VdbeCursor *p){
  int isDifferentRow, rc;
  assert( p->eCurType==CURTYPE_BTREE );
  assert( p->uc.pCursor!=0 );
  assert( sqlite3BtreeCursorHasMoved(p->uc.pCursor) );
  rc = sqlite3BtreeCursorRestore(p->uc.pCursor, &isDifferentRow);
  p->cacheStatus = CACHE_STALE;
  if( isDifferentRow ) p->nullRow = 1;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0x4007e0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x4007c9
movq -0x8(%rbp), %rax
movb $0x1, 0x2(%rax)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeCursorRestore
SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow){
  int rc;

  assert( pCur!=0 );
  assert( pCur->eState!=CURSOR_VALID );
  rc = restoreCursorPosition(pCur);
  if( rc ){
    *pDifferentRow = 1;
    return rc;
  }
  if( pCur->eState!=CURSOR_VALID ){
    *pDifferentRow = 1;
  }else{
    *pDifferentRow = 0;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3, %eax
jl 0x40080a
movq -0x10(%rbp), %rdi
callq 0x400870
movl %eax, -0x20(%rbp)
jmp 0x400811
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x400811
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x40082f
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x400858
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x400847
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x400851
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: btreeRestoreCursorPosition
static int btreeRestoreCursorPosition(BtCursor *pCur){
  int rc;
  int skipNext = 0;
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState>=CURSOR_REQUIRESEEK );
  if( pCur->eState==CURSOR_FAULT ){
    return pCur->skipNext;
  }
  pCur->eState = CURSOR_INVALID;
  if( sqlite3FaultSim(410) ){
    rc = SQLITE_IOERR;
  }else{
    rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
  }
  if( rc==SQLITE_OK ){
    sqlite3_free(pCur->pKey);
    pCur->pKey = 0;
    assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
    if( skipNext ) pCur->skipNext = skipNext;
    if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
      pCur->eState = CURSOR_SKIPNEXT;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x4, %eax
jne 0x40089e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x400933
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movl $0x19a, %edi            # imm = 0x19A
callq 0x3d5070
cmpl $0x0, %eax
je 0x4008bd
movl $0xa, -0x14(%rbp)
jmp 0x4008df
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
xorl %ecx, %ecx
leaq -0x18(%rbp), %r8
callq 0x400940
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x40092d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3c0800
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
cmpl $0x0, -0x18(%rbp)
je 0x40090e
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x40092b
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x40092b
movq -0x10(%rbp), %rax
movb $0x2, (%rax)
jmp 0x40092d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: btreeMoveto
static int btreeMoveto(
  BtCursor *pCur,     /* Cursor open on the btree to be searched */
  const void *pKey,   /* Packed key if the btree is an index */
  i64 nKey,           /* Integer key for tables.  Size of pKey for indices */
  int bias,           /* Bias search to the high end */
  int *pRes           /* Write search results here */
){
  int rc;                    /* Status code */
  UnpackedRecord *pIdxKey;   /* Unpacked index key */

  if( pKey ){
    KeyInfo *pKeyInfo = pCur->pKeyInfo;
    assert( nKey==(i64)(int)nKey );
    pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
    if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT;
    sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
    if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){
      rc = SQLITE_CORRUPT_BKPT;
      goto moveto_done;
    }
  }else{
    pIdxKey = 0;
  }
  rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
moveto_done:
  if( pIdxKey ){
    sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4009da
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3fbed0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x400991
movl $0x7, -0x4(%rbp)
jmp 0x400a22
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x3fbf60
movq -0x40(%rbp), %rax
movzwl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x4009c9
movq -0x40(%rbp), %rax
movzwl 0x10(%rax), %eax
movq -0x48(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jle 0x4009d8
movl $0xff15, %edi           # imm = 0xFF15
callq 0x3dff80
movl %eax, -0x34(%rbp)
jmp 0x4009fd
jmp 0x4009e2
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0x3fb680
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x400a1c
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x3c00a0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: fetchPayload
static const void *fetchPayload(
  BtCursor *pCur,      /* Cursor pointing to entry to read from */
  u32 *pAmt            /* Write the number of available bytes here */
){
  int amt;
  assert( pCur!=0 && pCur->iPage>=0 && pCur->pPage);
  assert( pCur->eState==CURSOR_VALID );
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->ix<pCur->pPage->nCell );
  assert( pCur->info.nSize>0 );
  assert( pCur->info.pPayload>pCur->pPage->aData || CORRUPT_DB );
  assert( pCur->info.pPayload<pCur->pPage->aDataEnd ||CORRUPT_DB);
  amt = pCur->info.nLocal;
  if( amt>(int)(pCur->pPage->aDataEnd - pCur->info.pPayload) ){
    /* There is too little space on the page for the expected amount
    ** of local content. Database must be corrupt. */
    assert( CORRUPT_DB );
    amt = MAX(0, (int)(pCur->pPage->aDataEnd - pCur->info.pPayload));
  }
  *pAmt = (u32)amt;
  return (void*)pCur->info.pPayload;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x44(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x88(%rcx), %rcx
movq 0x58(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rdx
subq %rdx, %rcx
cmpl %ecx, %eax
jle 0x400ab4
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x400a91
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x400aae
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: serialGet
static u32 serialGet(
  const unsigned char *buf,     /* Buffer to deserialize from */
  u32 serial_type,              /* Serial type to deserialize */
  Mem *pMem                     /* Memory cell to write value into */
){
  u64 x = FOUR_BYTE_UINT(buf);
  u32 y = FOUR_BYTE_UINT(buf+4);
  x = (x<<32) + y;
  if( serial_type==6 ){
    /* EVIDENCE-OF: R-29851-52272 Value is a big-endian 64-bit
    ** twos-complement integer. */
    pMem->u.i = *(i64*)&x;
    pMem->flags = MEM_Int;
    testcase( pMem->u.i<0 );
  }else{
    /* EVIDENCE-OF: R-57343-49114 Value is a big-endian IEEE 754-2008 64-bit
    ** floating point number. */
#if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
    /* Verify that integers and floating point values use the same
    ** byte order.  Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
    ** defined that 64-bit floating point values really are mixed
    ** endian.
    */
    static const u64 t1 = ((u64)0x3ff00000)<<32;
    static const double r1 = 1.0;
    u64 t2 = t1;
    swapMixedEndianFloat(t2);
    assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
#endif
    assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
    swapMixedEndianFloat(x);
    memcpy(&pMem->u.r, &x, sizeof(x));
    pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
  }
  return 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x4(%rax), %eax
shll $0x18, %eax
movq -0x8(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
shlq $0x20, %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpl $0x6, -0xc(%rbp)
jne 0x400b74
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movw $0x4, 0x8(%rax)
jmp 0x400bd7
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
andq -0x20(%rbp), %rcx
xorl %eax, %eax
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
movb %al, -0x25(%rbp)
jne 0x400bb9
movabsq $0xfffffffffffff, %rax  # imm = 0xFFFFFFFFFFFFF
andq -0x20(%rbp), %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %dl
movl $0x8, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x8(%rax)
movl $0x8, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: moveToParent
static void moveToParent(BtCursor *pCur){
  MemPage *pLeaf;
  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  assert( pCur->iPage>0 );
  assert( pCur->pPage );
  assertParentIndex(
    pCur->apPage[pCur->iPage-1],
    pCur->aiIdx[pCur->iPage-1],
    pCur->pPage->pgno
  );
  testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
  pCur->info.nSize = 0;
  pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
  pCur->ix = pCur->aiIdx[pCur->iPage-1];
  pLeaf = pCur->pPage;
  pCur->pPage = pCur->apPage[--pCur->iPage];
  releasePageNotNull(pLeaf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw $0x0, 0x46(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
andl $-0x7, %ecx
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movsbl 0x54(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw 0x58(%rax,%rcx,2), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x56(%rax)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movb 0x54(%rdx), %cl
addb $-0x1, %cl
movb %cl, 0x54(%rdx)
movsbq %cl, %rcx
movq 0x90(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rdi
callq 0x3e9ba0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: moveToChild
static int moveToChild(BtCursor *pCur, u32 newPgno){
  BtShared *pBt = pCur->pBt;

  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
  assert( pCur->iPage>=0 );
  if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
    return SQLITE_CORRUPT_BKPT;
  }
  pCur->info.nSize = 0;
  pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
  pCur->aiIdx[pCur->iPage] = pCur->ix;
  pCur->apPage[pCur->iPage] = pCur->pPage;
  pCur->ix = 0;
  pCur->iPage++;
  return getAndInitPage(pBt, newPgno, &pCur->pPage, pCur, pCur->curPagerFlags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x54(%rax), %eax
cmpl $0x13, %eax
jl 0x40104a
movl $0x10fd1, %edi          # imm = 0x10FD1
callq 0x3dff80
movl %eax, -0x4(%rbp)
jmp 0x4010da
movq -0x10(%rbp), %rax
movw $0x0, 0x46(%rax)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
andl $-0x7, %ecx
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movw 0x56(%rax), %dx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbq 0x54(%rcx), %rcx
movw %dx, 0x58(%rax,%rcx,2)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbq 0x54(%rcx), %rcx
movq %rdx, 0x90(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movw $0x0, 0x56(%rax)
movq -0x10(%rbp), %rax
movb 0x54(%rax), %cl
addb $0x1, %cl
movb %cl, 0x54(%rax)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x88, %rdx
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %r8d
callq 0x4010f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)