LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: verifyDbFile
static void verifyDbFile(unixFile *pFile){
  struct stat buf;
  int rc;
  rc = osFstat(pFile->h, &buf);
  if( rc!=0 ){
    sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink==0 && (pFile->ctrlFlags & UNIXFILE_DELETE)==0 ){
    sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink>1 ){
    sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
    return;
  }
  if( fileHasMoved(pFile) ){
    sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
movl 0x18(%rdi), %edi
leaq -0x98(%rbp), %rsi
callq *0x73ef2(%rip)          # 0x91810
testl %eax, %eax
je 0x1d943
movq 0x38(%rbx), %rdx
leaq 0x5d8f3(%rip), %rsi     # 0x7b220
movl $0x1c, %edi
xorl %eax, %eax
callq 0xa4c0
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %rbp
retq
movq -0x88(%rbp), %rax
cmpq $0x1, %rax
je 0x1d968
testq %rax, %rax
jne 0x1d9a2
testb $0x20, 0x1e(%rbx)
jne 0x1d968
movq 0x38(%rbx), %rdx
leaq 0x5d8d2(%rip), %rsi     # 0x7b238
jmp 0x1d92d
cmpq $0x0, 0x10(%rbx)
je 0x1d939
movq 0x38(%rbx), %rdi
leaq -0x128(%rbp), %rsi
callq *0x73e78(%rip)          # 0x917f8
testl %eax, %eax
jne 0x1d995
movq -0x120(%rbp), %rax
movq 0x10(%rbx), %rcx
cmpq 0x8(%rcx), %rax
je 0x1d939
movq 0x38(%rbx), %rdx
leaq 0x5d8d0(%rip), %rsi     # 0x7b270
jmp 0x1d92d
movq 0x38(%rbx), %rdx
leaq 0x5d8a8(%rip), %rsi     # 0x7b255
jmp 0x1d92d
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: unixFileLock
static int unixFileLock(unixFile *pFile, struct flock *pLock){
  int rc;
  unixInodeInfo *pInode = pFile->pInode;
  assert( unixMutexHeld() );
  assert( pInode!=0 );
  if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
    if( pInode->bProcessLock==0 ){
      struct flock lock;
      assert( pInode->nLock==0 );
      lock.l_whence = SEEK_SET;
      lock.l_start = SHARED_FIRST;
      lock.l_len = SHARED_SIZE;
      lock.l_type = F_WRLCK;
      rc = osFcntl(pFile->h, F_SETLK, &lock);
      if( rc<0 ) return rc;
      pInode->bProcessLock = 1;
      pInode->nLock++;
    }else{
      rc = 0;
    }
  }else{
    rc = osFcntl(pFile->h, F_SETLK, pLock);
  }
  return rc;
}

// Assembly:
movzwl 0x1e(%rdi), %eax
andl $0x3, %eax
cmpw $0x1, %ax
jne 0x1de26
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rbx
xorl %eax, %eax
cmpb $0x0, 0x15(%rbx)
jne 0x1de1f
movslq 0x73996(%rip), %rax     # 0x91780
addq $0x2, %rax
leaq -0x28(%rbp), %rdx
movq %rax, 0x8(%rdx)
movq $0x1fe, 0x10(%rdx)      # imm = 0x1FE
movl $0x1, (%rdx)
movl 0x18(%rdi), %edi
movl $0x6, %esi
xorl %eax, %eax
callq *0x73a2c(%rip)          # 0x91840
testl %eax, %eax
js 0x1de1f
movb $0x1, 0x15(%rbx)
incl 0x28(%rbx)
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rsi, %rdx
movq 0x73a10(%rip), %rcx     # 0x91840
movl 0x18(%rdi), %edi
movl $0x6, %esi
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: unixShmPurge
static void unixShmPurge(unixFile *pFd){
  unixShmNode *p = pFd->pInode->pShmNode;
  assert( unixMutexHeld() );
  if( p && ALWAYS(p->nRef==0) ){
    int nShmPerMap = unixShmRegionPerMap();
    int i;
    assert( p->pInode==pFd->pInode );
    sqlite3_mutex_free(p->mutex);
    for(i=0; i<p->nRegion; i+=nShmPerMap){
      if( p->h>=0 ){
        osMunmap(p->apRegion[i], p->szRegion);
      }else{
        sqlite3_free(p->apRegion[i]);
      }
    }
    sqlite3_free(p->apRegion);
    if( p->h>=0 ){
      robust_close(pFd, p->h, __LINE__);
      p->h = -1;
    }
    p->pInode->pShmNode = 0;
    sqlite3_free(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x1e136
cmpl $0x0, 0x30(%rbx)
je 0x1e13f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
callq *0x738a8(%rip)          # 0x919f0
movl %eax, %ecx
shrl $0xf, %ecx
cmpl $0x8000, %eax           # imm = 0x8000
movl $0x1, %r15d
cmovgel %ecx, %r15d
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e16b
callq *0x73245(%rip)          # 0x913b0
cmpw $0x0, 0x20(%rbx)
je 0x1e1ab
movl %r15d, %r15d
xorl %r12d, %r12d
cmpl $0x0, 0x18(%rbx)
js 0x1e192
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
movslq 0x1c(%rbx), %rsi
callq *0x73830(%rip)          # 0x919c0
jmp 0x1e19f
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0xa630
addq %r15, %r12
movzwl 0x20(%rbx), %eax
cmpq %rax, %r12
jb 0x1e178
movq 0x28(%rbx), %rdi
callq 0xa630
movl 0x18(%rbx), %esi
testl %esi, %esi
js 0x1e1cf
movq %r14, %rdi
movl $0x79e1, %edx           # imm = 0x79E1
callq 0x1dcda
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
movq (%rbx), %rax
movq $0x0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa630
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VMPrintf
SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
  assert( db!=0 );
  sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
                      db->aLimit[SQLITE_LIMIT_LENGTH]);
  sqlite3VXPrintf(&acc, SQLITE_PRINTF_INTERNAL, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  if( acc.accError==STRACCUM_NOMEM ){
    db->mallocFailed = 1;
  }
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movl 0x68(%rdi), %eax
leaq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %r14
movq %rsi, 0x8(%r14)
movq %rsi, 0x10(%r14)
movq %rdi, (%r14)
movabsq $0x4600000000, %rsi     # imm = 0x4600000000
movq %rsi, 0x18(%r14)
movl %eax, 0x20(%r14)
movw $0x0, 0x24(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0xc536
movq %r14, %rdi
callq 0xdbce
cmpb $0x1, 0x24(%r14)
jne 0x1e3ac
movb $0x1, 0x51(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheSetPageSize
SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *pCache, int szPage){
  assert( pCache->nRefSum==0 && pCache->pDirty==0 );
  if( pCache->szPage ){
    sqlite3_pcache *pNew;
    pNew = sqlite3GlobalConfig.pcache2.xCreate(
                szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)),
                pCache->bPurgeable
    );
    if( pNew==0 ) return SQLITE_NOMEM;
    sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache));
    if( pCache->pCache ){
      sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
    }
    pCache->pCache = pNew;
    pCache->szPage = szPage;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
cmpl $0x0, 0x24(%rdi)
je 0x1f755
movl %esi, %r14d
movq %rdi, %r15
movl 0x28(%rdi), %esi
addl $0x48, %esi
movzbl 0x2c(%rdi), %edx
movl %r14d, %edi
callq *0x71d03(%rip)          # 0x91400
testq %rax, %rax
je 0x1f750
movq %rax, %r12
movq 0x71cfc(%rip), %rcx     # 0x91408
movslq 0x1c(%r15), %rsi
testq %rsi, %rsi
jns 0x1f732
shlq $0xa, %rsi
negq %rsi
movslq 0x24(%r15), %rax
movslq 0x28(%r15), %rdi
addq %rax, %rdi
movq %rsi, %rax
cqto
idivq %rdi
movq %rax, %rsi
movq %r12, %rdi
callq *%rcx
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x1f746
callq *0x71cf2(%rip)          # 0x91438
movq %r12, 0x40(%r15)
movl %r14d, 0x24(%r15)
jmp 0x1f755
movl $0x7, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheMakeClean
SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){
  if( (p->flags & PGHDR_DIRTY) ){
    assert( (p->flags & PGHDR_CLEAN)==0 );
    pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);
    p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC|PGHDR_WRITEABLE);
    p->flags |= PGHDR_CLEAN;
    if( p->nRef==0 ){
      pcacheUnpin(p);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testb $0x2, 0x2c(%rdi)
je 0x2016f
movq %rdi, %rbx
movl $0x1, %esi
callq 0x21b0a
movl 0x2c(%rbx), %eax
andl $-0x10, %eax
incl %eax
movw %ax, 0x2c(%rbx)
cmpw $0x0, 0x2e(%rbx)
je 0x20176
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x30(%rbx), %rax
cmpb $0x0, 0x2c(%rax)
je 0x2016f
movq 0x71299(%rip), %rcx     # 0x91420
movq 0x40(%rax), %rdi
movq (%rbx), %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcacheManageDirtyList
static void pcacheManageDirtyList(PgHdr *pPage, u8 addRemove){
  PCache *p = pPage->pCache;

  if( addRemove & PCACHE_DIRTYLIST_REMOVE ){
    assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
    assert( pPage->pDirtyPrev || pPage==p->pDirty );
  
    /* Update the PCache1.pSynced variable if necessary. */
    if( p->pSynced==pPage ){
      PgHdr *pSynced = pPage->pDirtyPrev;
      while( pSynced && (pSynced->flags&PGHDR_NEED_SYNC) ){
        pSynced = pSynced->pDirtyPrev;
      }
      p->pSynced = pSynced;
    }
  
    if( pPage->pDirtyNext ){
      pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev;
    }else{
      assert( pPage==p->pDirtyTail );
      p->pDirtyTail = pPage->pDirtyPrev;
    }
    if( pPage->pDirtyPrev ){
      pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext;
    }else{
      assert( pPage==p->pDirty );
      p->pDirty = pPage->pDirtyNext;
      if( p->pDirty==0 && p->bPurgeable ){
        assert( p->eCreate==1 );
        p->eCreate = 2;
      }
    }
    pPage->pDirtyNext = 0;
    pPage->pDirtyPrev = 0;
  }
  if( addRemove & PCACHE_DIRTYLIST_ADD ){
    assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage );
  
    pPage->pDirtyNext = p->pDirty;
    if( pPage->pDirtyNext ){
      assert( pPage->pDirtyNext->pDirtyPrev==0 );
      pPage->pDirtyNext->pDirtyPrev = pPage;
    }else{
      p->pDirtyTail = pPage;
      if( p->bPurgeable ){
        assert( p->eCreate==2 );
        p->eCreate = 1;
      }
    }
    p->pDirty = pPage;
    if( !p->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){
      p->pSynced = pPage;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rax
testb $0x1, %sil
je 0x21b63
cmpq %rdi, 0x10(%rax)
jne 0x21b34
movq %rdi, %rcx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
je 0x21b30
testb $0x8, 0x2c(%rcx)
jne 0x21b21
movq %rcx, 0x10(%rax)
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
testq %rcx, %rcx
je 0x21b4f
movq %rdx, 0x40(%rcx)
testq %rdx, %rdx
jne 0x21b58
movq %rcx, (%rax)
jmp 0x21b5c
movq %rdx, 0x8(%rax)
testq %rdx, %rdx
je 0x21b9f
movq %rcx, 0x38(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
testb $0x2, %sil
je 0x21b9d
movq (%rax), %rcx
movq %rcx, 0x38(%rdi)
testq %rcx, %rcx
je 0x21b7b
movq %rdi, 0x40(%rcx)
jmp 0x21b89
movq %rdi, 0x8(%rax)
cmpb $0x0, 0x2c(%rax)
je 0x21b89
movb $0x1, 0x2d(%rax)
movq %rdi, (%rax)
cmpq $0x0, 0x10(%rax)
jne 0x21b9d
testb $0x8, 0x2c(%rdi)
jne 0x21b9d
movq %rdi, 0x10(%rax)
popq %rbp
retq
movq $0x0, (%rax)
cmpb $0x0, 0x2c(%rax)
je 0x21b5c
movb $0x2, 0x2d(%rax)
jmp 0x21b5c
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: btreeParseCellPtrNoPayload
static void btreeParseCellPtrNoPayload(
  MemPage *pPage,         /* Page containing the cell */
  u8 *pCell,              /* Pointer to the cell text. */
  CellInfo *pInfo         /* Fill in this structure */
){
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->leaf==0 );
  assert( pPage->noPayload );
  assert( pPage->childPtrSize==4 );
#ifndef SQLITE_DEBUG
  UNUSED_PARAMETER(pPage);
#endif
  pInfo->nSize = 4 + getVarint(&pCell[4], (u64*)&pInfo->nKey);
  pInfo->nPayload = 0;
  pInfo->nLocal = 0;
  pInfo->pPayload = 0;
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq 0x4(%rsi), %rdi
movq %rdx, %rsi
callq 0x22304
addb $0x4, %al
movzbl %al, %eax
movw %ax, 0x16(%rbx)
movl $0x0, 0x10(%rbx)
movw $0x0, 0x14(%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheTruncate
SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
  if( pCache->pCache ){
    PgHdr *p;
    PgHdr *pNext;
    for(p=pCache->pDirty; p; p=pNext){
      pNext = p->pDirtyNext;
      /* This routine never gets call with a positive pgno except right
      ** after sqlite3PcacheCleanAll().  So if there are dirty pages,
      ** it must be that pgno==0.
      */
      assert( p->pgno>0 );
      if( ALWAYS(p->pgno>pgno) ){
        assert( p->flags&PGHDR_DIRTY );
        sqlite3PcacheMakeClean(p);
      }
    }
    if( pgno==0 && pCache->nRefSum ){
      sqlite3_pcache_page *pPage1;
      pPage1 = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache,1,0);
      if( ALWAYS(pPage1) ){  /* Page 1 is always available in cache, because
                             ** pCache->nRefSum>0 */
        memset(pPage1->pBuf, 0, pCache->szPage);
        pgno = 1;
      }
    }
    sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
  }
}

// Assembly:
cmpq $0x0, 0x40(%rdi)
je 0x2264d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2262b
movq 0x38(%rdi), %r15
cmpl %r14d, 0x28(%rdi)
jbe 0x22623
callq 0x20143
movq %r15, %rdi
testq %r15, %r15
jne 0x22614
testl %r14d, %r14d
je 0x2264e
movq 0x6edf9(%rip), %rax     # 0x91430
movq 0x40(%rbx), %rdi
incl %r14d
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
retq
cmpl $0x0, 0x18(%rbx)
je 0x22683
movq 0x40(%rbx), %rdi
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq *0x6edb0(%rip)          # 0x91418
testq %rax, %rax
je 0x22630
movq (%rax), %rdi
movslq 0x24(%rbx), %rdx
xorl %esi, %esi
callq 0xa220
movl $0x1, %r14d
jmp 0x22630
xorl %r14d, %r14d
jmp 0x22630
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheDrop
SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){
  assert( p->nRef==1 );
  if( p->flags&PGHDR_DIRTY ){
    pcacheManageDirtyList(p, PCACHE_DIRTYLIST_REMOVE);
  }
  p->pCache->nRefSum--;
  sqlite3GlobalConfig.pcache2.xUnpin(p->pCache->pCache, p->pPage, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x2, 0x2c(%rdi)
je 0x24bcd
movq %rbx, %rdi
movl $0x1, %esi
callq 0x21b0a
movq 0x30(%rbx), %rax
decl 0x18(%rax)
movq 0x6c845(%rip), %rcx     # 0x91420
movq 0x40(%rax), %rdi
movq (%rbx), %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PagerUnrefNotNull
SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){
  Pager *pPager;
  assert( pPg!=0 );
  pPager = pPg->pPager;
  if( pPg->flags & PGHDR_MMAP ){
    pagerReleaseMapPage(pPg);
  }else{
    sqlite3PcacheRelease(pPg);
  }
  pagerUnlockIfUnused(pPager);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rbx
testb $0x40, 0x2c(%rdi)
jne 0x24e3f
callq 0x24f3c
jmp 0x24e7b
decl 0x98(%rbx)
movq 0xa8(%rbx), %rax
movq %rax, 0x18(%rdi)
movq %rdi, 0xa8(%rbx)
movq 0x48(%rbx), %rax
movl 0x28(%rdi), %ecx
decl %ecx
movslq 0xbc(%rbx), %rsi
imulq %rcx, %rsi
movq 0x8(%rdi), %rdx
movq (%rax), %rcx
movq %rax, %rdi
callq *0x90(%rcx)
cmpl $0x0, 0x98(%rbx)
jne 0x24e91
movq 0x110(%rbx), %rax
cmpl $0x0, 0x18(%rax)
je 0x24e98
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22901
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheRelease
SQLITE_NOINLINE sqlite3PcacheRelease(PgHdr *p){
  assert( p->nRef>0 );
  p->pCache->nRefSum--;
  if( (--p->nRef)==0 ){
    if( p->flags&PGHDR_CLEAN ){
      pcacheUnpin(p);
    }else if( p->pDirtyPrev!=0 ){
      /* Move the page to the head of the dirty list. */
      pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rax
decl 0x18(%rax)
decw 0x2e(%rdi)
je 0x24f4f
popq %rbp
retq
testb $0x1, 0x2c(%rdi)
jne 0x24f67
cmpq $0x0, 0x40(%rdi)
je 0x24f4d
movl $0x3, %esi
popq %rbp
jmp 0x21b0a
cmpb $0x0, 0x2c(%rax)
je 0x24f4d
movq 0x6c4ac(%rip), %rcx     # 0x91420
movq 0x40(%rax), %rax
movq (%rdi), %rsi
movq %rax, %rdi
xorl %edx, %edx
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheMakeDirty
SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){
  assert( p->nRef>0 );
  if( p->flags & (PGHDR_CLEAN|PGHDR_DONT_WRITE) ){
    p->flags &= ~PGHDR_DONT_WRITE;
    if( p->flags & PGHDR_CLEAN ){
      p->flags ^= (PGHDR_DIRTY|PGHDR_CLEAN);
      assert( (p->flags & (PGHDR_DIRTY|PGHDR_CLEAN))==PGHDR_DIRTY );
      pcacheManageDirtyList(p, PCACHE_DIRTYLIST_ADD);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x2c(%rdi), %eax
testb $0x21, %al
je 0x2503d
movl %eax, %ecx
andl $0xffdf, %ecx           # imm = 0xFFDF
movw %cx, 0x2c(%rdi)
testb $0x1, %al
jne 0x2503f
popq %rbp
retq
xorl $0x3, %ecx
movw %cx, 0x2c(%rdi)
movl $0x2, %esi
popq %rbp
jmp 0x21b0a
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: btreeLockCarefully
static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){
  Btree *pLater;

  /* In most cases, we should be able to acquire the lock we
  ** want without having to go through the ascending lock
  ** procedure that follows.  Just be sure not to block.
  */
  if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
    p->pBt->db = p->db;
    p->locked = 1;
    return;
  }

  /* To avoid deadlock, first release all locks with a larger
  ** BtShared address.  Then acquire our lock.  Then reacquire
  ** the other BtShared locks that we used to hold in ascending
  ** order.
  */
  for(pLater=p->pNext; pLater; pLater=pLater->pNext){
    assert( pLater->sharable );
    assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
    assert( !pLater->locked || pLater->wantToLock>0 );
    if( pLater->locked ){
      unlockBtreeMutex(pLater);
    }
  }
  lockBtreeMutex(p);
  for(pLater=p->pNext; pLater; pLater=pLater->pNext){
    if( pLater->wantToLock ){
      lockBtreeMutex(pLater);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x25282
callq *0x6c197(%rip)          # 0x913c0
testl %eax, %eax
je 0x2527e
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x2524b
cmpb $0x0, 0x12(%r14)
je 0x25245
movq %r14, %rdi
callq 0x25292
movq 0x20(%r14), %r14
jmp 0x25231
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x25262
callq *0x6c15a(%rip)          # 0x913b8
movq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x12(%rbx)
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x2528d
cmpl $0x0, 0x14(%rbx)
jne 0x2524b
jmp 0x2526d
movq 0x8(%rbx), %rax
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, 0x12(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: unlockBtreeMutex
static void SQLITE_NOINLINE unlockBtreeMutex(Btree *p){
  BtShared *pBt = p->pBt;
  assert( p->locked==1 );
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( sqlite3_mutex_held(p->db->mutex) );
  assert( p->db==pBt->db );

  sqlite3_mutex_leave(pBt->mutex);
  p->locked = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x252ae
callq *0x6c11a(%rip)          # 0x913c8
movb $0x0, 0x12(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/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 );
  nPage = sqlite3WalDbsize(pPager->pWal);

  /* If the number of pages in the database is not available from the
  ** WAL sub-system, determine the page counte 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 ){
    i64 n = 0;                    /* Size of db file in bytes */
    assert( isOpen(pPager->fd) || pPager->tempFile );
    if( isOpen(pPager->fd) ){
      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 %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x118(%rdi), %rax
testq %rax, %rax
je 0x25a18
cmpw $0x0, 0x3c(%rax)
js 0x25a18
movl 0x5c(%rax), %eax
testl %eax, %eax
jne 0x25a56
movq $0x0, -0x18(%rbp)
movq 0x48(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x25a40
leaq -0x18(%rbp), %rsi
callq *0x30(%rax)
testl %eax, %eax
jne 0x25a6a
movq -0x18(%rbp), %rax
decq %rax
jmp 0x25a47
movq $-0x1, %rax
movslq 0xbc(%r14), %rcx
addq %rcx, %rax
cqto
idivq %rcx
cmpl 0xc0(%r14), %eax
jbe 0x25a66
movl %eax, 0xc0(%r14)
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: saveCursorKey
static int saveCursorKey(BtCursor *pCur){
  int rc;
  assert( CURSOR_VALID==pCur->eState );
  assert( 0==pCur->pKey );
  assert( cursorHoldsMutex(pCur) );

  rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
  assert( rc==SQLITE_OK );  /* KeySize() cannot fail */

  /* If this is an intKey table, then the above call to BtreeKeySize()
  ** stores the integer key in pCur->nKey. In this case this value is
  ** all that is required. Otherwise, if pCur is not open on an intKey
  ** table, then malloc space for and store the pCur->nKey bytes of key 
  ** data.  */
  if( 0==pCur->curIntKey ){
    void *pKey = sqlite3Malloc( pCur->nKey );
    if( pKey ){
      rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
      if( rc==SQLITE_OK ){
        pCur->pKey = pKey;
      }else{
        sqlite3_free(pKey);
      }
    }else{
      rc = SQLITE_NOMEM;
    }
  }
  assert( !pCur->curIntKey || !pCur->pKey );
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x26c17
movq 0x20(%rbx), %rdi
movq %rdi, 0x38(%rbx)
xorl %r14d, %r14d
cmpb $0x0, 0x59(%rbx)
je 0x26bd2
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xc0e2
testq %rax, %rax
je 0x26c09
movq %rax, %r15
movl 0x38(%rbx), %edx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x26c6a
testl %eax, %eax
je 0x26c11
movl %eax, %r12d
movq %r15, %rdi
callq 0xa630
movl %r12d, %r14d
jmp 0x26bc6
movl $0x7, %r14d
jmp 0x26bc6
movq %r15, 0x40(%rbx)
jmp 0x26bc6
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PcacheMove
SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
  PCache *pCache = p->pCache;
  assert( p->nRef>0 );
  assert( newPgno>0 );
  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
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x40(%rax), %rdi
movq (%rbx), %rsi
movl 0x28(%rbx), %edx
movl %r14d, %ecx
callq *0x692ff(%rip)          # 0x91428
movl %r14d, 0x28(%rbx)
movl 0x2c(%rbx), %eax
notl %eax
testb $0xa, %al
jne 0x28147
movq %rbx, %rdi
movl $0x3, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: ptrmapPutOvflPtr
static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
  CellInfo info;
  if( *pRC ) return;
  assert( pCell!=0 );
  pPage->xParseCell(pPage, pCell, &info);
  if( info.nLocal<info.nPayload ){
    Pgno ovfl = get4byte(&pCell[info.nSize-4]);
    ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
  }
}

// Assembly:
cmpl $0x0, (%rdx)
je 0x2824a
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x38(%rbp), %r12
movq %r12, %rdx
callq *0x80(%rdi)
movzwl 0x14(%r12), %eax
cmpl %eax, 0x10(%r12)
jbe 0x2829f
movzwl -0x22(%rbp), %eax
movl -0x4(%r15,%rax), %esi
bswapl %esi
movq 0x48(%r14), %rdi
movl 0x88(%r14), %ecx
movl $0x3, %edx
movq %rbx, %r8
callq 0x27df6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/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){
      int i;
      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;
      }
      for(i=0; i<=p->iPage; i++){
        releasePage(p->apPage[i]);
        p->apPage[i] = 0;
      }
    }
    sqlite3BtreeLeave(pBtree);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2839e
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
je 0x282e3
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x282e3
movq %rbx, %rdi
callq 0x2520c
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r13
xorl %r14d, %r14d
testq %r13, %r13
je 0x28389
testl %r15d, %r15d
je 0x2831e
testb $0x1, 0x54(%r13)
jne 0x2831e
movb 0x56(%r13), %al
decb %al
cmpb $0x1, %al
ja 0x28338
movq %r13, %rdi
callq 0x26b0c
testl %eax, %eax
je 0x28338
jmp 0x283b3
movq 0x40(%r13), %rdi
callq 0xa630
movq $0x0, 0x40(%r13)
movb $0x4, 0x56(%r13)
movl %r12d, 0x50(%r13)
movb 0x58(%r13), %al
testb %al, %al
js 0x28379
movq $-0x1, %r14
movq 0xa0(%r13,%r14,8), %rcx
testq %rcx, %rcx
je 0x28361
movq 0x70(%rcx), %rdi
callq 0x24e28
movb 0x58(%r13), %al
movq $0x0, 0xa0(%r13,%r14,8)
movsbq %al, %rcx
incq %r14
cmpq %rcx, %r14
jl 0x28347
movq 0x10(%r13), %r13
testq %r13, %r13
jne 0x282f7
xorl %r14d, %r14d
cmpb $0x0, 0x11(%rbx)
je 0x283a1
decl 0x14(%rbx)
jne 0x283a1
movq %rbx, %rdi
callq 0x25292
jmp 0x283a1
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x282ac
jmp 0x28389
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: freeP4
static void freeP4(sqlite3 *db, int p4type, void *p4){
  if( p4 ){
    assert( db );
    switch( p4type ){
      case P4_FUNCCTX: {
        freeEphemeralFunction(db, ((sqlite3_context*)p4)->pFunc);
        /* Fall through into the next case */
      }
      case P4_REAL:
      case P4_INT64:
      case P4_DYNAMIC:
      case P4_INTARRAY: {
        sqlite3DbFree(db, p4);
        break;
      }
      case P4_KEYINFO: {
        if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4);
        break;
      }
#ifdef SQLITE_ENABLE_CURSOR_HINTS
      case P4_EXPR: {
        sqlite3ExprDelete(db, (Expr*)p4);
        break;
      }
#endif
      case P4_MPRINTF: {
        if( db->pnBytesFreed==0 ) sqlite3_free(p4);
        break;
      }
      case P4_FUNCDEF: {
        freeEphemeralFunction(db, (FuncDef*)p4);
        break;
      }
      case P4_MEM: {
        if( db->pnBytesFreed==0 ){
          sqlite3ValueFree((sqlite3_value*)p4);
        }else{
          Mem *p = (Mem*)p4;
          if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
          sqlite3DbFree(db, p);
        }
        break;
      }
      case P4_VTAB : {
        if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4);
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x2856f
addl $0x14, %esi
cmpl $0x13, %esi
ja 0x2856f
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4ef3f(%rip), %rax     # 0x77428
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb752
cmpq $0x0, 0x328(%r14)
jne 0x2856f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x28580
cmpq $0x0, 0x328(%r14)
je 0x28574
cmpl $0x0, 0x20(%rbx)
je 0x284f2
movq 0x18(%rbx), %rsi
jmp 0x28539
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x284f2
testb $0x10, 0x2(%rsi)
je 0x284f2
movq %r14, %rdi
callq 0xb752
jmp 0x284f2
testb $0x10, 0x2(%rbx)
jne 0x284f2
jmp 0x2856f
cmpq $0x0, 0x328(%r14)
jne 0x2856f
decl (%rbx)
jne 0x2856f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa630
cmpq $0x0, 0x328(%r14)
je 0x28559
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x11a2a
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeTransferError
SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
  sqlite3 *db = p->db;
  int rc = p->rc;
  if( p->zErrMsg ){
    u8 mallocFailed = db->mallocFailed;
    sqlite3BeginBenignMalloc();
    if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
    sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
    sqlite3EndBenignMalloc();
    db->mallocFailed = mallocFailed;
    db->errCode = rc;
  }else{
    sqlite3Error(db, rc);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r14
movl 0x84(%rdi), %ebx
cmpq $0x0, 0x48(%rdi)
je 0x28c39
movq %rdi, %r15
movb 0x51(%r14), %r12b
movq 0x6a93d(%rip), %rax     # 0x934e8
testq %rax, %rax
je 0x28bb2
callq *%rax
movq 0x140(%r14), %rdi
testq %rdi, %rdi
jne 0x28bfe
movl $0x38, %esi
movq %r14, %rdi
callq 0x145aa
testq %rax, %rax
je 0x28c5b
movq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x30(%rax)
movw $0x1, 0x8(%rax)
movq %r14, 0x28(%rax)
movq %rax, 0x140(%r14)
movq 0x48(%r15), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x11bc0
movq 0x6a8d1(%rip), %rax     # 0x934f0
testq %rax, %rax
je 0x28c26
callq *%rax
movb %r12b, 0x51(%r14)
movl %ebx, 0x44(%r14)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, 0x44(%r14)
movq 0x140(%r14), %rdi
testq %rdi, %rdi
je 0x28c2e
movzwl 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x28c68
callq 0x2a210
jmp 0x28c2e
movq $0x0, 0x140(%r14)
jmp 0x28c18
movw $0x1, 0x8(%rdi)
jmp 0x28c2e
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeDeleteAuxData
SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(Vdbe *pVdbe, int iOp, int mask){
  AuxData **pp = &pVdbe->pAuxData;
  while( *pp ){
    AuxData *pAux = *pp;
    if( (iOp<0)
     || (pAux->iOp==iOp && (pAux->iArg>31 || !(mask & MASKBIT32(pAux->iArg))))
    ){
      testcase( pAux->iArg==31 );
      if( pAux->xDelete ){
        pAux->xDelete(pAux->pAux);
      }
      *pp = pAux->pNext;
      sqlite3DbFree(pVdbe->db, pAux);
    }else{
      pp= &pAux->pNext;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x120(%rdi), %r12
testq %r12, %r12
je 0x29783
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x120(%rdi), %r13
testl %r14d, %r14d
js 0x29755
cmpl %r14d, (%r12)
jne 0x2974c
movl 0x4(%r12), %eax
cmpl $0x1f, %eax
jg 0x29755
btl %eax, %ebx
jae 0x29755
addq $0x18, %r12
movq %r12, %r13
jmp 0x2977a
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x29766
movq 0x8(%r12), %rdi
callq *%rax
movq 0x18(%r12), %rax
movq %rax, (%r13)
movq (%r15), %rdi
movq %r12, %rsi
callq 0xb752
movq (%r13), %r12
testq %r12, %r12
jne 0x29732
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeFreeCursor
SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
  if( pCx==0 ){
    return;
  }
  assert( pCx->pBt==0 || pCx->eCurType==CURTYPE_BTREE );
  switch( pCx->eCurType ){
    case CURTYPE_SORTER: {
      sqlite3VdbeSorterClose(p->db, pCx);
      break;
    }
    case CURTYPE_BTREE: {
      if( pCx->pBt ){
        sqlite3BtreeClose(pCx->pBt);
        /* 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x297e8
movq %rsi, %rbx
movzbl (%rsi), %eax
testl %eax, %eax
je 0x2980d
cmpl $0x2, %eax
je 0x297f3
cmpl $0x1, %eax
jne 0x297e8
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x297e8
movq (%rdi), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x29ac7
movq 0x40(%r14), %rdi
callq 0xa630
movq %r15, %rdi
movq %r14, %rsi
callq 0xb752
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
decl 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x38(%rcx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x29822
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29835
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x299cc
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeCloseCursor
SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
  Btree *pBtree = pCur->pBtree;
  if( pBtree ){
    int i;
    BtShared *pBt = pCur->pBt;
    sqlite3BtreeEnter(pBtree);
    sqlite3BtreeClearCursor(pCur);
    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) );
    }
    for(i=0; i<=pCur->iPage; i++){
      releasePage(pCur->apPage[i]);
    }
    unlockBtreeIfUnused(pBt);
    sqlite3_free(pCur->aOverflow);
    /* sqlite3_free(pCur); */
    sqlite3BtreeLeave(pBtree);
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x29aae
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpb $0x0, 0x11(%rbx)
je 0x29a01
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x29a01
movq %rbx, %rdi
callq 0x2520c
movq 0x40(%r14), %rdi
callq 0xa630
movq $0x0, 0x40(%r14)
movb $0x0, 0x56(%r14)
movq 0x10(%r15), %rax
cmpq %r14, %rax
je 0x29a33
movq 0x10(%rax), %rcx
cmpq %r14, %rcx
je 0x29a39
movq %rcx, %rax
testq %rcx, %rcx
jne 0x29a20
jmp 0x29a44
leaq 0x10(%r15), %rax
jmp 0x29a3d
addq $0x10, %rax
movq 0x10(%r14), %rcx
movq %rcx, (%rax)
movb 0x58(%r14), %al
testb %al, %al
js 0x29a79
movq $-0x1, %r12
movq 0xa0(%r14,%r12,8), %rcx
testq %rcx, %rcx
je 0x29a6d
movq 0x70(%rcx), %rdi
callq 0x24e28
movb 0x58(%r14), %al
movsbq %al, %rcx
incq %r12
cmpq %rcx, %r12
jl 0x29a53
cmpb $0x0, 0x24(%r15)
jne 0x29a9a
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x29a9a
movq $0x0, 0x18(%r15)
movq 0x70(%rax), %rdi
callq 0x24e28
movq 0x18(%r14), %rdi
callq 0xa630
cmpb $0x0, 0x11(%rbx)
je 0x29aae
decl 0x14(%rbx)
je 0x29ab7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25292
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeSorterJoinThread
static int vdbeSorterJoinThread(SortSubtask *pTask){
  int rc = SQLITE_OK;
  if( pTask->pThread ){
#ifdef SQLITE_DEBUG_SORTER_THREADS
    int bDone = pTask->bDone;
#endif
    void *pRet = SQLITE_INT_TO_PTR(SQLITE_ERROR);
    vdbeSorterBlockDebug(pTask, !bDone, "enter");
    (void)sqlite3ThreadJoin(pTask->pThread, &pRet);
    vdbeSorterBlockDebug(pTask, !bDone, "exit");
    rc = SQLITE_PTR_TO_INT(pRet);
    assert( pTask->bDone==1 );
    pTask->bDone = 0;
    pTask->pThread = 0;
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r14
testq %r14, %r14
je 0x29d43
movq %rdi, %rbx
movq $0x1, -0x18(%rbp)
cmpl $0x0, 0x8(%r14)
je 0x29d47
movq 0x10(%r14), %rax
movq %rax, -0x18(%rbp)
jmp 0x29d53
xorl %eax, %eax
jmp 0x29d6c
movq (%r14), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa560
movq %r14, %rdi
callq 0xa630
movl -0x18(%rbp), %eax
movl $0x0, 0x8(%rbx)
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeLeave
static SQLITE_NOINLINE void vdbeLeave(Vdbe *p){
  int i;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  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) ){
      sqlite3BtreeLeave(aDb[i].pBt);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movslq 0x28(%rax), %r14
testq %r14, %r14
jle 0x29f84
movq %rdi, %rbx
movq 0x20(%rax), %r15
addq $0x8, %r15
xorl %r12d, %r12d
cmpq $0x1, %r12
je 0x29f78
movl 0x98(%rbx), %eax
btl %r12d, %eax
jae 0x29f78
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29f78
cmpb $0x0, 0x11(%rdi)
je 0x29f78
decl 0x14(%rdi)
jne 0x29f78
callq 0x25292
incq %r12
addq $0x20, %r15
cmpq %r12, %r14
jne 0x29f4e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeMemClear
static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
  if( VdbeMemDynamic(p) ){
    vdbeMemClearExternAndSetNull(p);
  }
  if( p->szMalloc ){
    sqlite3DbFree(p->db, p->zMalloc);
    p->szMalloc = 0;
  }
  p->z = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x2a1e7
movq %rbx, %rdi
callq 0x2a210
cmpl $0x0, 0x20(%rbx)
je 0x2a201
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0xb752
movl $0x0, 0x20(%rbx)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/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->flags&MEM_RowSet)==0 );
    assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
    p->xDel((void *)p->z);
  }else if( p->flags&MEM_RowSet ){
    sqlite3RowSetClear(p->u.pRowSet);
  }else if( p->flags&MEM_Frame ){
    VdbeFrame *pFrame = p->u.pFrame;
    pFrame->pParent = pFrame->v->pDelFrame;
    pFrame->v->pDelFrame = pFrame;
  }
  p->flags = MEM_Null;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
btl $0xd, %eax
jae 0x2a231
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x2a27a
movzwl 0x8(%rbx), %eax
movzwl %ax, %eax
btl $0xa, %eax
jb 0x2a25c
testb $0x20, %al
jne 0x2a265
testb $0x40, %al
je 0x2a26d
movq (%rbx), %rax
movq (%rax), %rcx
movq 0xf8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0xf8(%rcx)
jmp 0x2a26d
movq 0x10(%rbx), %rdi
callq *0x30(%rbx)
jmp 0x2a26d
movq (%rbx), %rdi
callq 0x2a31b
movw $0x1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeMemFinalize
SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
  int rc = SQLITE_OK;
  if( ALWAYS(pFunc && pFunc->xFinalize) ){
    sqlite3_context ctx;
    Mem t;
    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 ) sqlite3DbFree(pMem->db, pMem->zMalloc);
    memcpy(pMem, &t, sizeof(t));
    rc = ctx.isError;
  }
  return rc;
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x2a31a
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x2a31a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x78(%rbp), %rdi
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
leaq -0x40(%rbp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movw $0x1, 0x8(%rax)
movq 0x28(%rbx), %rdx
movq %rdx, 0x28(%rax)
movq %rax, (%rdi)
movq %rbx, 0x10(%rdi)
movq %rsi, 0x8(%rdi)
callq *%rcx
cmpl $0x0, 0x20(%rbx)
jle 0x2a2f2
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0xb752
movq -0x10(%rbp), %rax
movq %rax, 0x30(%rbx)
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movaps -0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl -0x54(%rbp), %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeMemGrow
int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
  assert( sqlite3VdbeCheckMemInvariants(pMem) );
  assert( (pMem->flags&MEM_RowSet)==0 );

  /* If the bPreserve flag is set to true, then the memory cell must already
  ** contain a valid string or blob value.  */
  assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
  testcase( bPreserve && pMem->z==0 );

  assert( pMem->szMalloc==0
       || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) );
  if( pMem->szMalloc<n ){
    if( n<32 ) n = 32;
    if( bPreserve && pMem->szMalloc>0 && pMem->z==pMem->zMalloc ){
      pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
      bPreserve = 0;
    }else{
      if( pMem->szMalloc>0 ) sqlite3DbFree(pMem->db, pMem->zMalloc);
      pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
    }
    if( pMem->zMalloc==0 ){
      sqlite3VdbeMemSetNull(pMem);
      pMem->z = 0;
      pMem->szMalloc = 0;
      return SQLITE_NOMEM;
    }else{
      pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
    }
  }

  if( bPreserve && pMem->z && pMem->z!=pMem->zMalloc ){
    memcpy(pMem->zMalloc, pMem->z, pMem->n);
  }
  if( (pMem->flags&MEM_Dyn)!=0 ){
    assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
    pMem->xDel((void *)(pMem->z));
  }

  pMem->z = pMem->zMalloc;
  pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl %esi, %eax
jge 0x2a417
cmpl $0x21, %esi
movl $0x20, %r15d
cmovgel %esi, %r15d
testl %r14d, %r14d
sete %cl
testl %eax, %eax
setle %dl
orb %cl, %dl
jne 0x2a3ba
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
cmpq %rax, %rsi
jne 0x2a3c2
movq 0x28(%rbx), %rdi
movl %r15d, %edx
callq 0x2a49a
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
jmp 0x2a3de
testl %eax, %eax
jle 0x2a3ce
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0xb752
movq 0x28(%rbx), %rdi
movl %r15d, %esi
callq 0x145aa
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x2a469
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x2a40b
cmpq %rax, 0x170(%rcx)
ja 0x2a40b
cmpq %rax, 0x178(%rcx)
jbe 0x2a40b
movzwl 0x150(%rcx), %eax
jmp 0x2a414
movq %rax, %rdi
callq *0x66f5c(%rip)          # 0x91370
movl %eax, 0x20(%rbx)
testl %r14d, %r14d
je 0x2a437
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2a437
movq 0x18(%rbx), %rdi
cmpq %rdi, %rsi
je 0x2a437
movslq 0xc(%rbx), %rdx
callq 0xa320
movl 0x8(%rbx), %eax
btl $0xa, %eax
jae 0x2a44b
movq 0x10(%rbx), %rdi
callq *0x30(%rbx)
movzwl 0x8(%rbx), %eax
movq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rbx)
andl $0xe3ff, %eax           # imm = 0xE3FF
movw %ax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x8(%rbx), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x2a47e
movq %rbx, %rdi
callq 0x2a210
jmp 0x2a484
movw $0x1, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movl $0x7, %eax
jmp 0x2a45e
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/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( (pVal->flags & MEM_RowSet)==0 );
  assert( (pVal->flags & (MEM_Null))==0 );
  if( pVal->flags & (MEM_Blob|MEM_Str) ){
    pVal->flags |= MEM_Str;
    if( pVal->flags & MEM_Zero ){
      sqlite3VdbeMemExpandBlob(pVal);
    }
    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) ){
    return pVal->z;
  }else{
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testb $0x12, %al
je 0x2a56b
movl %eax, %ecx
orl $0x2, %ecx
movw %cx, 0x8(%rbx)
btl $0xe, %eax
jae 0x2a51d
movq %rbx, %rdi
callq 0x116fb
movzbl 0xa(%rbx), %eax
movzbl %r14b, %esi
andl $-0x9, %esi
cmpl %eax, %esi
je 0x2a53a
testb $0x2, 0x8(%rbx)
je 0x2a53a
movq %rbx, %rdi
callq 0x2a679
testb $0x8, %r14b
je 0x2a552
testb $0x1, 0x10(%rbx)
je 0x2a552
movq %rbx, %rdi
callq 0x119a7
testl %eax, %eax
jne 0x2a589
movzwl 0x8(%rbx), %eax
andl $0x202, %eax            # imm = 0x202
cmpw $0x2, %ax
jne 0x2a579
movq %rbx, %rdi
callq 0x2ac29
jmp 0x2a579
movzbl %r14b, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2a590
andb $-0x9, %r14b
cmpb %r14b, 0xa(%rbx)
jne 0x2a589
movq 0x10(%rbx), %rax
jmp 0x2a58b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq