LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeCursor
SQLITE_PRIVATE int sqlite3BtreeCursor(
  Btree *p,                                   /* The btree */
  int iTable,                                 /* Root page of table to open */
  int wrFlag,                                 /* 1 to write. 0 read-only */
  struct KeyInfo *pKeyInfo,                   /* First arg to xCompare() */
  BtCursor *pCur                              /* Write new cursor here */
){
  int rc;
  if( iTable<1 ){
    rc = SQLITE_CORRUPT_BKPT;
  }else{
    sqlite3BtreeEnter(p);
    rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
    sqlite3BtreeLeave(p);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x33384
movq %r8, %r14
movl %edx, %r13d
movl %esi, %r15d
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
je 0x332c2
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x332c2
movq %rbx, %rdi
movq %rcx, %r12
callq 0x25420
movq %r12, %rcx
movq 0x8(%rbx), %r12
testl %r13d, %r13d
je 0x33314
cmpq $0x0, 0x80(%r12)
jne 0x33305
movl 0x30(%r12), %edi
movq %rcx, -0x30(%rbp)
callq 0x22616
movq -0x30(%rbp), %rcx
movq %rax, 0x80(%r12)
testq %rax, %rax
je 0x33305
movq $0x0, (%rax)
addq $0x4, 0x80(%r12)
cmpq $0x0, 0x80(%r12)
je 0x333ab
cmpl $0x1, %r15d
jne 0x33327
xorl %r15d, %r15d
cmpl $0x0, 0x3c(%r12)
setne %r15b
testl %r13d, %r13d
sete %al
movl %r15d, 0x48(%r14)
movb $-0x1, 0x58(%r14)
movq %rcx, 0x60(%r14)
movq %rbx, (%r14)
movq %r12, 0x8(%r14)
setne 0x54(%r14)
addb %al, %al
movb %al, 0x55(%r14)
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x33371
movq %rax, %rcx
cmpl %r15d, 0x48(%rcx)
jne 0x33368
orb $0x20, 0x54(%rcx)
orb $0x20, 0x54(%r14)
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x33359
movq %rax, 0x10(%r14)
movq %r14, 0x10(%r12)
movb $0x0, 0x56(%r14)
xorl %r14d, %r14d
jmp 0x333b1
leaq 0x4a14d(%rip), %rsi     # 0x7d4d8
leaq 0x49deb(%rip), %rcx     # 0x7d17d
movl $0xb, %r14d
movl $0xb, %edi
movl $0xe786, %edx           # imm = 0xE786
xorl %eax, %eax
callq 0xa4b0
jmp 0x333c4
movl $0x7, %r14d
cmpb $0x0, 0x11(%rbx)
je 0x333c4
decl 0x14(%rbx)
jne 0x333c4
movq %rbx, %rdi
callq 0x254a6
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeNext
SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
  MemPage *pPage;
  assert( cursorHoldsMutex(pCur) );
  assert( pRes!=0 );
  assert( *pRes==0 || *pRes==1 );
  assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
  pCur->info.nSize = 0;
  pCur->curFlags &= ~(BTCF_ValidNKey|BTCF_ValidOvfl);
  *pRes = 0;
  if( pCur->eState!=CURSOR_VALID ) return btreeNext(pCur, pRes);
  pPage = pCur->apPage[pCur->iPage];
  if( (++pCur->aiIdx[pCur->iPage])>=pPage->nCell ){
    pCur->aiIdx[pCur->iPage]--;
    return btreeNext(pCur, pRes);
  }
  if( pPage->leaf ){
    return SQLITE_OK;
  }else{
    return moveToLeftmost(pCur);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw $0x0, 0x36(%rdi)
andb $-0x7, 0x54(%rdi)
movl $0x0, (%rsi)
cmpb $0x1, 0x56(%rdi)
jne 0x33ee6
movsbq 0x58(%rdi), %rax
movq 0x98(%rdi,%rax,8), %rcx
movzwl 0x70(%rdi,%rax,2), %edx
leal 0x1(%rdx), %r8d
movw %r8w, 0x70(%rdi,%rax,2)
cmpw 0x12(%rcx), %r8w
jae 0x33ee1
cmpb $0x0, 0x5(%rcx)
je 0x33eec
xorl %eax, %eax
popq %rbp
retq
movw %dx, 0x70(%rdi,%rax,2)
popq %rbp
jmp 0x38034
popq %rbp
jmp 0x3814d
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreePrevious
SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
  assert( cursorHoldsMutex(pCur) );
  assert( pRes!=0 );
  assert( *pRes==0 || *pRes==1 );
  assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
  *pRes = 0;
  pCur->curFlags &= ~(BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey);
  pCur->info.nSize = 0;
  if( pCur->eState!=CURSOR_VALID
   || pCur->aiIdx[pCur->iPage]==0
   || pCur->apPage[pCur->iPage]->leaf==0
  ){
    return btreePrevious(pCur, pRes);
  }
  pCur->aiIdx[pCur->iPage]--;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, (%rsi)
andb $-0xf, 0x54(%rdi)
movw $0x0, 0x36(%rdi)
cmpb $0x1, 0x56(%rdi)
jne 0x33f34
movsbq 0x58(%rdi), %rax
movzwl 0x70(%rdi,%rax,2), %ecx
testw %cx, %cx
je 0x33f34
movq 0x98(%rdi,%rax,8), %rdx
cmpb $0x0, 0x5(%rdx)
je 0x33f34
decl %ecx
movw %cx, 0x70(%rdi,%rax,2)
xorl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x381b7
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeRecordUnpack
SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(
  KeyInfo *pKeyInfo,     /* Information about the record format */
  int nKey,              /* Size of the binary record */
  const void *pKey,      /* The binary record */
  UnpackedRecord *p      /* Populate this structure before returning. */
){
  const unsigned char *aKey = (const unsigned char *)pKey;
  int d; 
  u32 idx;                        /* Offset in aKey[] to read from */
  u16 u;                          /* Unsigned loop counter */
  u32 szHdr;
  Mem *pMem = p->aMem;

  p->default_rc = 0;
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  idx = getVarint32(aKey, szHdr);
  d = szHdr;
  u = 0;
  while( idx<szHdr && d<=nKey ){
    u32 serial_type;

    idx += getVarint32(&aKey[idx], serial_type);
    pMem->enc = pKeyInfo->enc;
    pMem->db = pKeyInfo->db;
    /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
    pMem->szMalloc = 0;
    d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem);
    pMem++;
    if( (++u)>=p->nField ) break;
  }
  assert( u<=pKeyInfo->nField + 1 );
  p->nField = u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, -0x34(%rbp)
movq %rdi, -0x48(%rbp)
movq 0x8(%rcx), %r13
movq %rcx, -0x40(%rbp)
movb $0x0, 0x12(%rcx)
movsbl (%rdx), %eax
testl %eax, %eax
js 0x33fd6
movl %eax, -0x30(%rbp)
movl $0x1, %ebx
jmp 0x33fe5
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x32d61
movzbl %al, %ebx
movl -0x30(%rbp), %r12d
xorl %r15d, %r15d
movl %r12d, -0x38(%rbp)
cmpl -0x38(%rbp), %ebx
jae 0x34062
cmpl -0x34(%rbp), %r12d
jg 0x34062
movl %ebx, %edi
movsbl (%r14,%rdi), %eax
testl %eax, %eax
js 0x34010
movl %eax, -0x2c(%rbp)
movl $0x1, %eax
jmp 0x3401f
addq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x32d61
movzbl %al, %eax
addl %eax, %ebx
movq -0x48(%rbp), %rcx
movb 0x4(%rcx), %al
movb %al, 0xa(%r13)
movq 0x10(%rcx), %rax
movq %rax, 0x28(%r13)
movl $0x0, 0x20(%r13)
movslq %r12d, %rdi
addq %r14, %rdi
movl -0x2c(%rbp), %esi
movq %r13, %rdx
callq 0x32e1f
addl %eax, %r12d
addq $0x38, %r13
incl %r15d
movq -0x40(%rbp), %rax
cmpw 0x10(%rax), %r15w
jb 0x33ff0
movq -0x40(%rbp), %rax
movw %r15w, 0x10(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeSorterCompare
SQLITE_PRIVATE int sqlite3VdbeSorterCompare(
  const VdbeCursor *pCsr,         /* Sorter cursor */
  Mem *pVal,                      /* Value to compare to current sorter key */
  int nKeyCol,                    /* Compare this many columns */
  int *pRes                       /* OUT: Result of comparison */
){
  VdbeSorter *pSorter;
  UnpackedRecord *r2;
  KeyInfo *pKeyInfo;
  int i;
  void *pKey; int nKey;           /* Sorter key to compare pVal with */

  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  r2 = pSorter->pUnpacked;
  pKeyInfo = pCsr->pKeyInfo;
  if( r2==0 ){
    char *p;
    r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo,0,0,&p);
    assert( pSorter->pUnpacked==(UnpackedRecord*)p );
    if( r2==0 ) return SQLITE_NOMEM;
    r2->nField = nKeyCol;
  }
  assert( r2->nField==nKeyCol );

  pKey = vdbeSorterRowkey(pSorter, &nKey);
  sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2);
  for(i=0; i<nKeyCol; i++){
    if( r2->aMem[i].flags & MEM_Null ){
      *pRes = -1;
      return SQLITE_OK;
    }
  }

  *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x30(%rbp)
movl %edx, %r12d
movq %rsi, %r14
movq 0x10(%rdi), %rbx
movq 0x20(%rdi), %r13
movq 0x30(%rbx), %r15
testq %r15, %r15
jne 0x34a15
leaq -0x38(%rbp), %rcx
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33f3a
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x34aac
movq %rax, %r15
movw %r12w, 0x10(%rax)
cmpb $0x0, 0x58(%rbx)
je 0x34a27
cmpb $0x0, 0x59(%rbx)
je 0x34a31
movq 0x10(%rbx), %rax
jmp 0x34a49
movq 0x38(%rbx), %rax
leaq 0x10(%rax), %rdx
jmp 0x34a51
movq 0x18(%rbx), %rcx
movq 0x10(%rcx), %rax
movslq 0x4(%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq 0x18(%rcx), %rax
movq 0x28(%rax), %rdx
addq $0x14, %rax
movl (%rax), %esi
movq %r13, %rdi
movq %r15, %rcx
callq 0x33f9e
testl %r12d, %r12d
jle 0x34a80
movq 0x8(%r15), %rax
movl %r12d, %ecx
imulq $0x38, %rcx, %rcx
xorl %edx, %edx
testb $0x1, 0x8(%rax,%rdx)
jne 0x34a9d
addq $0x38, %rdx
cmpq %rdx, %rcx
jne 0x34a70
movl 0xc(%r14), %edi
movq 0x10(%r14), %rsi
xorl %r14d, %r14d
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x37947
movq -0x30(%rbp), %rcx
movl %eax, (%rcx)
jmp 0x34ab2
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorl %r14d, %r14d
jmp 0x34ab2
movl $0x7, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeSorterRowkey
SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
  VdbeSorter *pSorter;
  void *pKey; int nKey;           /* Sorter key to copy into pOut */

  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  pKey = vdbeSorterRowkey(pSorter, &nKey);
  if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){
    return SQLITE_NOMEM;
  }
  pOut->n = nKey;
  MemSetTypeFlag(pOut, MEM_Blob);
  memcpy(pOut->z, pKey, nKey);

  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rax
cmpb $0x0, 0x58(%rax)
je 0x34ae7
cmpb $0x0, 0x59(%rax)
je 0x34af1
movq 0x10(%rax), %rax
jmp 0x34b09
movq 0x38(%rax), %rax
leaq 0x10(%rax), %r14
jmp 0x34b11
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %rax
movslq 0x4(%rax), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq 0x18(%rcx), %rax
movq 0x28(%rax), %r14
addq $0x14, %rax
movl (%rax), %r15d
cmpl %r15d, 0x20(%rbx)
jge 0x34b34
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x2a792
movl %eax, %ecx
movl $0x7, %eax
testl %ecx, %ecx
jne 0x34b65
jmp 0x34b41
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
andw $0xd, 0x8(%rbx)
movl %r15d, 0xc(%rbx)
movl $0xffffbe00, %eax       # imm = 0xFFFFBE00
andl 0x8(%rbx), %eax
movslq %r15d, %rdx
orl $0x10, %eax
movw %ax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0xa310
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeSorterNext
SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr, int *pbEof){
  VdbeSorter *pSorter;
  int rc;                         /* Return code */

  assert( pCsr->eCurType==CURTYPE_SORTER );
  pSorter = pCsr->uc.pSorter;
  assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) );
  if( pSorter->bUsePMA ){
    assert( pSorter->pReader==0 || pSorter->pMerger==0 );
    assert( pSorter->bUseThreads==0 || pSorter->pReader );
    assert( pSorter->bUseThreads==1 || pSorter->pMerger );
#if SQLITE_MAX_WORKER_THREADS>0
    if( pSorter->bUseThreads ){
      rc = vdbePmaReaderNext(pSorter->pReader);
      *pbEof = (pSorter->pReader->pFd==0);
    }else
#endif
    /*if( !pSorter->bUseThreads )*/ {
      assert( pSorter->pMerger!=0 );
      assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );
      rc = vdbeMergeEngineStep(pSorter->pMerger, pbEof);
    }
  }else{
    SorterRecord *pFree = pSorter->list.pList;
    pSorter->list.pList = pFree->u.pNext;
    pFree->u.pNext = 0;
    if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree);
    *pbEof = !pSorter->list.pList;
    rc = SQLITE_OK;
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq 0x10(%rsi), %r15
cmpb $0x0, 0x58(%r15)
je 0x34bab
cmpb $0x0, 0x59(%r15)
je 0x34bf9
movq 0x10(%r15), %rdi
callq 0x3c709
movq 0x10(%r15), %rcx
xorl %edx, %edx
cmpq $0x0, 0x18(%rcx)
sete %dl
movl %edx, (%rbx)
jmp 0x34bf0
movq 0x38(%r15), %rsi
movq 0x8(%rsi), %rax
movq %rax, 0x38(%r15)
movq $0x0, 0x8(%rsi)
testq %rsi, %rsi
je 0x34be2
cmpq $0x0, 0x40(%r15)
jne 0x34be2
movq %rdi, %r14
movq 0x8(%rsi), %r12
movq %r14, %rdi
callq 0xb6df
movq %r12, %rsi
testq %r12, %r12
jne 0x34bce
xorl %eax, %eax
cmpq $0x0, 0x38(%r15)
sete %al
movl %eax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3cb77
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3UnlinkAndDeleteIndex
SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
  Index *pIndex;
  Hash *pHash;

  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  pHash = &db->aDb[iDb].pSchema->idxHash;
  pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
  if( ALWAYS(pIndex) ){
    if( pIndex->pTable->pIndex==pIndex ){
      pIndex->pTable->pIndex = pIndex->pNext;
    }else{
      Index *p;
      /* Justification of ALWAYS();  The index must be on the list of
      ** indices. */
      p = pIndex->pTable->pIndex;
      while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
      if( ALWAYS(p && p->pNext==pIndex) ){
        p->pNext = pIndex->pNext;
      }
    }
    freeIndex(db, pIndex);
  }
  db->flags |= SQLITE_InternChanges;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
movq 0x18(%rax,%rcx), %rdi
addq $0x20, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x3d5df
testq %rax, %rax
je 0x3561b
movq 0x18(%rax), %rcx
movq 0x10(%rcx), %rdx
cmpq %rax, %rdx
je 0x35605
testq %rdx, %rdx
je 0x35610
movq %rdx, %rcx
movq 0x28(%rdx), %rdx
cmpq %rax, %rdx
jne 0x355ee
addq $0x28, %rcx
jmp 0x35609
addq $0x10, %rcx
movq 0x28(%rax), %rdx
movq %rdx, (%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d8a8
orb $0x2, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeMemSetRowSet
SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
  sqlite3 *db = pMem->db;
  assert( db!=0 );
  assert( (pMem->flags & MEM_RowSet)==0 );
  sqlite3VdbeMemRelease(pMem);
  pMem->zMalloc = sqlite3DbMallocRaw(db, 64);
  if( db->mallocFailed ){
    pMem->flags = MEM_Null;
    pMem->szMalloc = 0;
  }else{
    assert( pMem->zMalloc );
    pMem->szMalloc = sqlite3DbMallocSize(db, pMem->zMalloc);
    pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc, pMem->szMalloc);
    assert( pMem->u.pRowSet!=0 );
    pMem->flags = MEM_RowSet;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movzwl 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
jne 0x35ab6
cmpl $0x0, 0x20(%rbx)
je 0x35abe
movq %rbx, %rdi
callq 0x2a601
movl $0x40, %esi
movq %r14, %rdi
callq 0x144ee
movq %rax, 0x18(%rbx)
cmpb $0x0, 0x51(%r14)
je 0x35ae5
movw $0x1, 0x8(%rbx)
movl $0x0, 0x20(%rbx)
jmp 0x35b62
testq %r14, %r14
je 0x35b06
cmpq %rax, 0x170(%r14)
ja 0x35b06
cmpq %rax, 0x178(%r14)
jbe 0x35b06
movzwl 0x150(%r14), %eax
jmp 0x35b0f
movq %rax, %rdi
callq *0x5d851(%rip)          # 0x93360
movl %eax, 0x20(%rbx)
movq 0x18(%rbx), %rcx
xorl %edx, %edx
movq %rdx, (%rcx)
movq %r14, 0x8(%rcx)
movq %rdx, 0x28(%rcx)
leaq 0x38(%rcx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
movl %eax, %eax
addq $-0x38, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
movq %rsi, 0x20(%rcx)
shrl $0x4, %edx
movw %dx, 0x30(%rcx)
movw $0x1, 0x32(%rcx)
movl $0x0, 0x34(%rcx)
movq %rcx, (%rbx)
movw $0x20, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/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 ) rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, iSvpt-1);
      }
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x1a4(%rdi), %rax
testq %rax, %rax
jle 0x3657d
cmpq $0x0, 0x1c8(%r14)
je 0x365cb
xorl %ebx, %ebx
testq %r15, %r15
je 0x365d4
movq 0x10(%r15), %rcx
movq (%rcx), %r12
cmpq $0x0, 0x70(%r12)
je 0x365d4
testl %eax, %eax
jle 0x365ae
movq 0x1c8(%r14), %rcx
xorl %edx, %edx
cmpq %r15, (%rcx,%rdx,8)
je 0x365d2
incq %rdx
cmpq %rdx, %rax
jne 0x365a0
movq %r14, %rdi
callq 0x3ef65
testl %eax, %eax
jne 0x365c7
movq 0x10(%r15), %rdi
callq *0x70(%r12)
testl %eax, %eax
je 0x365df
movl %eax, %ebx
jmp 0x365d4
movl $0x6, %ebx
jmp 0x365d4
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x30c(%r14), %eax
movq 0x1c8(%r14), %rcx
movslq 0x1a4(%r14), %rsi
leal 0x1(%rsi), %edx
movl %edx, 0x1a4(%r14)
movl 0x310(%r14), %edx
movq %r15, (%rcx,%rsi,8)
incl 0x18(%r15)
addl %eax, %edx
je 0x365d4
decl %edx
movq %r14, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a549
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/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].zName);
  if( ALWAYS(pTab!=0 && 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;
    assert( xDestroy!=0 );  /* Checked before the virtual table is created */
    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);
    }
  }

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1abce
xorl %r12d, %r12d
testq %rax, %rax
je 0x367f6
movq %rax, %rbx
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x367f6
movq %rax, %rcx
movq 0x10(%rcx), %rdx
cmpl $0x0, 0x8(%rdx)
jg 0x367f0
movq 0x28(%rcx), %rcx
testq %rcx, %rcx
jne 0x36772
movq $0x0, 0x58(%rbx)
xorl %r15d, %r15d
movq (%rax), %rdx
movq 0x28(%rax), %rcx
cmpq %r14, %rdx
je 0x367b0
movq 0x1d0(%rdx), %rsi
movq %rsi, 0x28(%rax)
movq %rax, 0x1d0(%rdx)
jmp 0x367bf
movq %rax, 0x58(%rbx)
movq $0x0, 0x28(%rax)
movq %rax, %r15
movq %rcx, %rax
testq %rcx, %rcx
jne 0x36790
movq 0x8(%r15), %rax
movq 0x10(%r15), %rdi
movq (%rax), %rax
callq *0x28(%rax)
movl %eax, %r12d
testl %eax, %eax
jne 0x367f6
xorl %eax, %eax
movq %rax, 0x10(%r15)
movq %rax, 0x58(%rbx)
movq %r15, %rdi
callq 0x289bd
jmp 0x367f6
movl $0x6, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/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;
    int n1, n2;
    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);
    n1 = v1==0 ? 0 : c1.n;
    v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
    n2 = v2==0 ? 0 : c2.n;
    rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
    sqlite3VdbeMemRelease(&c1);
    sqlite3VdbeMemRelease(&c2);
    if( (v1==0 || v2==0) && prcErr ) *prcErr = SQLITE_NOMEM;
    return rc;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
movb 0xa(%rdi), %dl
cmpb 0x8(%r14), %dl
jne 0x36e57
movq 0x10(%r14), %rdi
movq 0x18(%r14), %r9
movl 0xc(%rax), %esi
movq 0x10(%rax), %rdx
movl 0xc(%r15), %ecx
movq 0x10(%r15), %r8
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%r9
movq %rcx, -0x30(%rbp)
movq 0x28(%rax), %rcx
movw $0x1, %dx
leaq -0xa0(%rbp), %rbx
movw %dx, 0x8(%rbx)
movq %rcx, 0x28(%rbx)
xorl %r12d, %r12d
movl %r12d, 0x20(%rbx)
leaq -0x68(%rbp), %r13
movw %dx, 0x8(%r13)
movq %rcx, 0x28(%r13)
movl %r12d, 0x20(%r13)
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x328d1
movq %r13, %rdi
movq %r15, %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x328d1
movzbl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x11820
movq %rax, %r15
movl $0x0, %ebx
testq %rax, %rax
je 0x36eca
movl -0x94(%rbp), %ebx
movzbl 0x8(%r14), %esi
movq %r13, %rdi
callq 0x11820
movq %rax, %r13
testq %rax, %rax
je 0x36ee3
movl -0x5c(%rbp), %r12d
movq 0x10(%r14), %rdi
movl %ebx, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r8
callq *0x18(%r14)
movl %eax, %r14d
movzwl -0x98(%rbp), %eax
testl $0x2460, %eax           # imm = 0x2460
jne 0x36f0d
cmpl $0x0, -0x80(%rbp)
je 0x36f19
leaq -0xa0(%rbp), %rdi
callq 0x2a601
movzwl -0x60(%rbp), %eax
testl $0x2460, %eax           # imm = 0x2460
jne 0x36f2a
cmpl $0x0, -0x48(%rbp)
je 0x36f33
leaq -0x68(%rbp), %rdi
callq 0x2a601
testq %r13, %r13
sete %al
testq %r15, %r15
sete %cl
movq -0x30(%rbp), %rdx
testq %rdx, %rdx
je 0x36f4f
orb %al, %cl
je 0x36f4f
movb $0x7, (%rdx)
movl %r14d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeMemFromBtreeResize
static SQLITE_NOINLINE int vdbeMemFromBtreeResize(
  BtCursor *pCur,   /* Cursor pointing at record to retrieve. */
  u32 offset,       /* Offset from the start of data to return bytes from. */
  u32 amt,          /* Number of bytes to return. */
  int key,          /* If true, retrieve from the btree key, not data. */
  Mem *pMem         /* OUT: Return data in this Mem structure. */
){
  int rc;
  pMem->flags = MEM_Null;
  if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+2)) ){
    if( key ){
      rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
    }else{
      rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
    }
    if( rc==SQLITE_OK ){
      pMem->z[amt] = 0;
      pMem->z[amt+1] = 0;
      pMem->flags = MEM_Blob|MEM_Term;
      pMem->n = (int)amt;
    }else{
      sqlite3VdbeMemRelease(pMem);
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %edx
movq %rdi, %r13
movw $0x1, 0x8(%r8)
leal 0x2(%r14), %esi
cmpl %esi, 0x20(%r8)
jge 0x371f2
movq %rbx, %rdi
movl %edx, %r15d
xorl %edx, %edx
callq 0x2a792
movl %r15d, %edx
movl %eax, %r15d
jmp 0x37203
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
movw $0x1, 0x8(%rbx)
xorl %r15d, %r15d
testl %r15d, %r15d
jne 0x3726e
movq 0x10(%rbx), %rcx
movq %r13, %rdi
movl %edx, %esi
movl %r14d, %edx
testl %r12d, %r12d
je 0x37223
xorl %r8d, %r8d
callq 0x26ef2
jmp 0x37228
callq 0x1535b
movl %eax, %r15d
testl %eax, %eax
je 0x3724a
movzwl 0x8(%rbx), %eax
testl $0x2460, %eax           # imm = 0x2460
jne 0x37240
cmpl $0x0, 0x20(%rbx)
je 0x3726e
movq %rbx, %rdi
callq 0x2a601
jmp 0x3726e
movq 0x10(%rbx), %rax
movl %r14d, %ecx
xorl %r15d, %r15d
movb %r15b, (%rax,%rcx)
movq 0x10(%rbx), %rax
leal 0x1(%r14), %ecx
movb %r15b, (%rax,%rcx)
movw $0x210, 0x8(%rbx)       # imm = 0x210
movl %r14d, 0xc(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: moveToChild
static int moveToChild(BtCursor *pCur, u32 newPgno){
  BtShared *pBt = pCur->pBt;

  assert( cursorHoldsMutex(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->iPage++;
  pCur->aiIdx[pCur->iPage] = 0;
  return getAndInitPage(pBt, newPgno, &pCur->apPage[pCur->iPage],
                        pCur, pCur->curPagerFlags);
}

// Assembly:
movb 0x58(%rdi), %al
cmpb $0x13, %al
jl 0x374c5
pushq %rbp
movq %rsp, %rbp
leaq 0x46032(%rip), %rsi     # 0x7d4d8
leaq 0x45cd0(%rip), %rcx     # 0x7d17d
movl $0xb, %edi
movl $0xe9e8, %edx           # imm = 0xE9E8
xorl %eax, %eax
callq 0xa4b0
movl $0xb, %eax
popq %rbp
retq
movq %rdi, %rcx
movq 0x8(%rdi), %rdi
xorl %edx, %edx
movw %dx, 0x36(%rcx)
andb $-0x7, 0x54(%rcx)
incb %al
movb %al, 0x58(%rcx)
movsbq %al, %rax
movw %dx, 0x70(%rcx,%rax,2)
leaq (%rcx,%rax,8), %rdx
addq $0x98, %rdx
movzbl 0x55(%rcx), %r8d
jmp 0x374f6
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: btreePrevious
static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur, int *pRes){
  int rc;
  MemPage *pPage;

  assert( cursorHoldsMutex(pCur) );
  assert( pRes!=0 );
  assert( *pRes==0 );
  assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
  assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
  assert( pCur->info.nSize==0 );
  if( pCur->eState!=CURSOR_VALID ){
    rc = restoreCursorPosition(pCur);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    if( CURSOR_INVALID==pCur->eState ){
      *pRes = 1;
      return SQLITE_OK;
    }
    if( pCur->skipNext ){
      assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
      pCur->eState = CURSOR_VALID;
      if( pCur->skipNext<0 ){
        pCur->skipNext = 0;
        return SQLITE_OK;
      }
      pCur->skipNext = 0;
    }
  }

  pPage = pCur->apPage[pCur->iPage];
  assert( pPage->isInit );
  if( !pPage->leaf ){
    int idx = pCur->aiIdx[pCur->iPage];
    rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
    if( rc ) return rc;
    rc = moveToRightmost(pCur);
  }else{
    while( pCur->aiIdx[pCur->iPage]==0 ){
      if( pCur->iPage==0 ){
        pCur->eState = CURSOR_INVALID;
        *pRes = 1;
        return SQLITE_OK;
      }
      moveToParent(pCur);
    }
    assert( pCur->info.nSize==0 );
    assert( (pCur->curFlags & (BTCF_ValidNKey|BTCF_ValidOvfl))==0 );

    pCur->aiIdx[pCur->iPage]--;
    pPage = pCur->apPage[pCur->iPage];
    if( pPage->intKey && !pPage->leaf ){
      rc = sqlite3BtreePrevious(pCur, pRes);
    }else{
      rc = SQLITE_OK;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0x56(%rdi), %cl
cmpb $0x1, %cl
jne 0x3821e
movsbq 0x58(%rbx), %rcx
movq 0x98(%rbx,%rcx,8), %rax
cmpb $0x0, 0x5(%rax)
je 0x38285
movb 0x58(%rbx), %cl
movsbq %cl, %rax
movzwl 0x70(%rbx,%rax,2), %edx
testw %dx, %dx
jne 0x38259
testb %cl, %cl
je 0x382c0
movw $0x0, 0x36(%rbx)
andb $-0x7, 0x54(%rbx)
decb %cl
movb %cl, 0x58(%rbx)
movq 0x98(%rbx,%rax,8), %rax
movq 0x70(%rax), %rdi
callq 0x25020
jmp 0x381e3
xorl %eax, %eax
cmpb $0x3, %cl
jb 0x3822d
movq %rbx, %rdi
callq 0x3704a
testl %eax, %eax
jne 0x382cd
cmpb $0x0, 0x56(%rbx)
je 0x382c4
movl 0x50(%rbx), %eax
testl %eax, %eax
je 0x381cc
movb $0x1, 0x56(%rbx)
movl $0x0, 0x50(%rbx)
jns 0x381cc
jmp 0x382cb
decl %edx
movw %dx, 0x70(%rbx,%rax,2)
movq 0x98(%rbx,%rax,8), %rcx
xorl %eax, %eax
cmpb $0x0, 0x2(%rcx)
je 0x382cd
cmpb $0x0, 0x5(%rcx)
jne 0x382cd
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x33ef2
movzwl 0x70(%rbx,%rcx,2), %ecx
movzwl 0x14(%rax), %edx
movq 0x50(%rax), %rsi
movq 0x60(%rax), %rax
movzbl (%rax,%rcx,2), %edi
shll $0x8, %edi
movzbl 0x1(%rax,%rcx,2), %eax
orl %edi, %eax
andl %edx, %eax
movl (%rsi,%rax), %esi
bswapl %esi
movq %rbx, %rdi
callq 0x37494
testl %eax, %eax
jne 0x382cd
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x382d2
movb $0x0, 0x56(%rbx)
movl $0x1, (%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: moveToRightmost
static int moveToRightmost(BtCursor *pCur){
  Pgno pgno;
  int rc = SQLITE_OK;
  MemPage *pPage = 0;

  assert( cursorHoldsMutex(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  while( !(pPage = pCur->apPage[pCur->iPage])->leaf ){
    pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
    pCur->aiIdx[pCur->iPage] = pPage->nCell;
    rc = moveToChild(pCur, pgno);
    if( rc ) return rc;
  }
  pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
  assert( pCur->info.nSize==0 );
  assert( (pCur->curFlags & BTCF_ValidNKey)==0 );
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsbq 0x58(%rbx), %rax
movq 0x98(%rbx,%rax,8), %rcx
cmpb $0x0, 0x5(%rcx)
jne 0x38313
movq 0x50(%rcx), %rdx
movzbl 0x6(%rcx), %esi
movl 0x8(%rdx,%rsi), %esi
bswapl %esi
movzwl 0x12(%rcx), %ecx
movw %cx, 0x70(%rbx,%rax,2)
movq %rbx, %rdi
callq 0x37494
testl %eax, %eax
je 0x382db
jmp 0x38320
movzwl 0x12(%rcx), %ecx
decl %ecx
movw %cx, 0x70(%rbx,%rax,2)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: invalidateIncrblobCursors
static void invalidateIncrblobCursors(
  Btree *pBtree,          /* The database file to check */
  i64 iRow,               /* The rowid that might be changing */
  int isClearTable        /* True if all rows are being deleted */
){
  BtCursor *p;
  if( pBtree->hasIncrblobCur==0 ) return;
  assert( sqlite3BtreeHoldsMutex(pBtree) );
  pBtree->hasIncrblobCur = 0;
  for(p=pBtree->pBt->pCursor; p; p=p->pNext){
    if( (p->curFlags & BTCF_Incrblob)!=0 ){
      pBtree->hasIncrblobCur = 1;
      if( isClearTable || p->info.nKey==iRow ){
        p->eState = CURSOR_INVALID;
      }
    }
  }
}

// Assembly:
cmpb $0x0, 0x13(%rdi)
je 0x3835d
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x13(%rdi)
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x3835c
testb $0x10, 0x54(%rax)
je 0x38339
movb $0x1, 0x13(%rdi)
testl %edx, %edx
jne 0x38356
cmpq %rsi, 0x20(%rax)
jne 0x38339
movb $0x0, 0x56(%rax)
jmp 0x38339
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pageInsertArray
static int pageInsertArray(
  MemPage *pPg,                   /* Page to add cells to */
  u8 *pBegin,                     /* End of cell-pointer array */
  u8 **ppData,                    /* IN/OUT: Page content -area pointer */
  u8 *pCellptr,                   /* Pointer to cell-pointer area */
  int iFirst,                     /* Index of first cell to add */
  int nCell,                      /* Number of cells to add to pPg */
  CellArray *pCArray              /* Array of cells */
){
  int i;
  u8 *aData = pPg->aData;
  u8 *pData = *ppData;
  int iEnd = iFirst + nCell;
  assert( CORRUPT_DB || pPg->hdrOffset==0 );    /* Never called on page 1 */
  for(i=iFirst; i<iEnd; i++){
    int sz, rc;
    u8 *pSlot;
    sz = cachedCellSize(pCArray, i);
    if( (aData[1]==0 && aData[2]==0) || (pSlot = pageFindSlot(pPg,sz,&rc))==0 ){
      pData -= sz;
      if( pData<pBegin ) return 1;
      pSlot = pData;
    }
    /* pSlot and pCArray->apCell[i] will never overlap on a well-formed
    ** database.  But they might for a corrupt database.  Hence use memmove()
    ** since memcpy() sends SIGABORT with overlapping buffers on OpenBSD */
    assert( (pSlot+sz)<=pCArray->apCell[i]
         || pSlot>=(pCArray->apCell[i]+sz)
         || CORRUPT_DB );
    memmove(pSlot, pCArray->apCell[i], sz);
    put2byte(pCellptr, (pSlot - aData));
    pCellptr += 2;
  }
  *ppData = pData;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq (%rdx), %rax
testl %r9d, %r9d
movq %rax, -0x30(%rbp)
jle 0x3b513
movq %rcx, %r14
addl %r8d, %r9d
movq %rdi, -0x48(%rbp)
movq 0x50(%rdi), %r13
movslq %r8d, %rbx
movslq %r9d, %rax
movq %rax, -0x50(%rbp)
movq 0x10(%rbp), %rax
movq 0x18(%rax), %rax
movzwl (%rax,%rbx,2), %eax
testw %ax, %ax
jne 0x3b499
movq 0x10(%rbp), %rdi
movl %ebx, %esi
callq 0x3b2ed
movzwl %ax, %esi
cmpb $0x0, 0x1(%r13)
movl %esi, %r15d
jne 0x3b4ad
cmpb $0x0, 0x2(%r13)
je 0x3b4c4
movq -0x48(%rbp), %rdi
leaq -0x54(%rbp), %rdx
callq 0x3aa53
testq %rax, %rax
je 0x3b4c4
movq %rax, %r12
jmp 0x3b4d9
movq -0x30(%rbp), %r12
subq %r15, %r12
cmpq -0x40(%rbp), %r12
movq %r12, -0x30(%rbp)
jae 0x3b4d9
xorl %eax, %eax
jmp 0x3b502
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax,%rbx,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xa440
subl %r13d, %r12d
rolw $0x8, %r12w
movw %r12w, (%r14)
addq $0x2, %r14
movb $0x1, %al
testb %al, %al
je 0x3b522
incq %rbx
cmpq -0x50(%rbp), %rbx
jl 0x3b47d
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
xorl %eax, %eax
jmp 0x3b527
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeSorterSort
static int vdbeSorterSort(SortSubtask *pTask, SorterList *pList){
  int i;
  SorterRecord **aSlot;
  SorterRecord *p;
  int rc;

  rc = vdbeSortAllocUnpacked(pTask);
  if( rc!=SQLITE_OK ) return rc;

  p = pList->pList;
  pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter);

  aSlot = (SorterRecord **)sqlite3MallocZero(64 * sizeof(SorterRecord *));
  if( !aSlot ){
    return SQLITE_NOMEM;
  }

  while( p ){
    SorterRecord *pNext;
    if( pList->aMemory ){
      if( (u8*)p==pList->aMemory ){
        pNext = 0;
      }else{
        assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
        pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
      }
    }else{
      pNext = p->u.pNext;
    }

    p->u.pNext = 0;
    for(i=0; aSlot[i]; i++){
      vdbeSorterMerge(pTask, p, aSlot[i], &p);
      aSlot[i] = 0;
    }
    aSlot[i] = p;
    p = pNext;
  }

  p = 0;
  for(i=0; i<64; i++){
    vdbeSorterMerge(pTask, p, aSlot[i], &p);
  }
  pList->pList = p;

  sqlite3_free(aSlot);
  assert( pTask->pUnpacked->errCode==SQLITE_OK 
       || pTask->pUnpacked->errCode==SQLITE_NOMEM 
  );
  return pTask->pUnpacked->errCode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %rbx
callq 0x3b7f1
testl %eax, %eax
jne 0x3b67e
movq (%r13), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rbx), %rax
movb 0x5c(%rax), %al
cmpb $0x2, %al
leaq 0x4b6(%rip), %rcx       # 0x3ba28
leaq 0x5c1(%rip), %rdx       # 0x3bb3a
cmoveq %rcx, %rdx
cmpb $0x1, %al
leaq 0x390(%rip), %rax       # 0x3b916
cmovneq %rdx, %rax
movq %rax, 0x40(%rbx)
movl $0x200, %edi            # imm = 0x200
callq 0xbf9b
testq %rax, %rax
je 0x3b679
movq %rax, %r14
movl $0x200, %edx            # imm = 0x200
movq %rax, %rdi
xorl %esi, %esi
callq 0xa210
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x3b634
leaq -0x30(%rbp), %r12
movq %r13, -0x38(%rbp)
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x3b5db
cmpq %r13, %rax
je 0x3b5e1
movslq 0x8(%rax), %rcx
addq %rcx, %r13
jmp 0x3b5e4
movq 0x8(%rax), %r13
jmp 0x3b5e4
xorl %r13d, %r13d
movq $0x0, 0x8(%rax)
movq (%r14), %rdx
movq %r14, %r15
testq %rdx, %rdx
je 0x3b61d
movq %r14, %r15
movq -0x30(%rbp), %rsi
movq %rbx, %rdi
movq %r12, %rcx
callq 0x3b853
movq $0x0, (%r15)
movq 0x8(%r15), %rdx
addq $0x8, %r15
testq %rdx, %rdx
jne 0x3b5fa
movq -0x30(%rbp), %rax
movq %rax, (%r15)
movq %r13, -0x30(%rbp)
movq %r13, %rax
testq %r13, %r13
movq -0x38(%rbp), %r13
jne 0x3b5c4
leaq -0x30(%rbp), %r12
movq $0x0, (%r12)
xorl %r15d, %r15d
movq -0x30(%rbp), %rsi
movq (%r14,%r15,8), %rdx
movq %rbx, %rdi
movq %r12, %rcx
callq 0x3b853
incq %r15
cmpq $0x40, %r15
jne 0x3b643
movq -0x30(%rbp), %rax
movq %rax, (%r13)
movq %r14, %rdi
callq 0xa620
movq 0x18(%rbx), %rax
movzbl 0x13(%rax), %eax
jmp 0x3b67e
movl $0x7, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeSortAllocUnpacked
static int vdbeSortAllocUnpacked(SortSubtask *pTask){
  if( pTask->pUnpacked==0 ){
    char *pFree;
    pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(
        pTask->pSorter->pKeyInfo, 0, 0, &pFree
    );
    assert( pTask->pUnpacked==(UnpackedRecord*)pFree );
    if( pFree==0 ) return SQLITE_NOMEM;
    pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nField;
    pTask->pUnpacked->errCode = 0;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq $0x0, 0x18(%rdi)
jne 0x3b846
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rdi
xorl %ebx, %ebx
leaq -0x20(%rbp), %r15
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x33f3a
movq %rax, 0x18(%r14)
cmpq $0x0, (%r15)
je 0x3b841
movq 0x10(%r14), %rcx
movq 0x28(%rcx), %rcx
movzwl 0x6(%rcx), %ecx
movw %cx, 0x10(%rax)
movb $0x0, 0x13(%rax)
jmp 0x3b846
movl $0x7, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeSorterMerge
static void vdbeSorterMerge(
  SortSubtask *pTask,             /* Calling thread context */
  SorterRecord *p1,               /* First list to merge */
  SorterRecord *p2,               /* Second list to merge */
  SorterRecord **ppOut            /* OUT: Head of merged list */
){
  SorterRecord *pFinal = 0;
  SorterRecord **pp = &pFinal;
  int bCached = 0;

  while( p1 && p2 ){
    int res;
    res = pTask->xCompare(
        pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal
    );

    if( res<=0 ){
      *pp = p1;
      pp = &p1->u.pNext;
      p1 = p1->u.pNext;
    }else{
      *pp = p2;
      pp = &p2->u.pNext;
      p2 = p2->u.pNext;
      bCached = 0;
    }
  }
  *pp = p1 ? p1 : p2;
  *ppOut = pFinal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, %r15
movq %rsi, %r14
movq $0x0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
testq %rsi, %rsi
setne %al
sete %cl
testq %rdx, %rdx
sete %dl
orb %cl, %dl
jne 0x3b8ef
movq %rdi, %r12
leaq -0x38(%rbp), %rbx
leaq -0x2c(%rbp), %r13
leaq 0x10(%r14), %rdx
movl (%r14), %ecx
leaq 0x10(%r15), %r8
movl (%r15), %r9d
movq %r12, %rdi
movq %r13, %rsi
callq *0x40(%r12)
testl %eax, %eax
jle 0x3b8cf
movq %r15, (%rbx)
movq %r15, %rbx
movq 0x8(%r15), %r15
addq $0x8, %rbx
movl $0x0, -0x2c(%rbp)
jmp 0x3b8e0
movq %r14, (%rbx)
movq 0x8(%r14), %rax
addq $0x8, %r14
movq %r14, %rbx
movq %rax, %r14
testq %r14, %r14
setne %al
je 0x3b8f3
testq %r15, %r15
jne 0x3b89b
jmp 0x3b8f3
leaq -0x38(%rbp), %rbx
testb %al, %al
cmovneq %r14, %r15
movq %r15, (%rbx)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeSorterCompareText
static int vdbeSorterCompareText(
  SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */
  int *pbKey2Cached,              /* True if pTask->pUnpacked is pKey2 */
  const void *pKey1, int nKey1,   /* Left side of comparison */
  const void *pKey2, int nKey2    /* Right side of comparison */
){
  const u8 * const p1 = (const u8 * const)pKey1;
  const u8 * const p2 = (const u8 * const)pKey2;
  const u8 * const v1 = &p1[ p1[0] ];   /* Pointer to value 1 */
  const u8 * const v2 = &p2[ p2[0] ];   /* Pointer to value 2 */

  int n1;
  int n2;
  int res;

  getVarint32(&p1[1], n1); n1 = (n1 - 13) / 2;
  getVarint32(&p2[1], n2); n2 = (n2 - 13) / 2;
  res = memcmp(v1, v2, MIN(n1, n2));
  if( res==0 ){
    res = n1 - n2;
  }

  if( res==0 ){
    if( pTask->pSorter->pKeyInfo->nField>1 ){
      res = vdbeSorterCompareTail(
          pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2
      );
    }
  }else{
    if( pTask->pSorter->pKeyInfo->aSortOrder[0] ){
      res = res * -1;
    }
  }

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, -0x38(%rbp)
movq %r8, %rbx
movl %ecx, -0x34(%rbp)
movq %rdx, %r12
movq %rsi, -0x40(%rbp)
movzbl (%rdx), %r15d
movzbl (%r8), %r13d
movsbl 0x1(%rdx), %eax
testl %eax, %eax
movq %rdi, -0x50(%rbp)
js 0x3ba63
movl %eax, -0x30(%rbp)
jmp 0x3ba71
leaq 0x1(%r12), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d61
addq %r12, %r15
addq %rbx, %r13
movl -0x30(%rbp), %eax
movl %eax, %ecx
addl $-0xd, %ecx
shrl $0x1f, %ecx
leal (%rax,%rcx), %r14d
addl $-0xd, %r14d
sarl %r14d
movl %r14d, -0x30(%rbp)
movsbl 0x1(%rbx), %eax
testl %eax, %eax
movq %rbx, -0x48(%rbp)
js 0x3baa2
movl %eax, -0x2c(%rbp)
jmp 0x3baaf
leaq 0x1(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x32d61
movl -0x2c(%rbp), %eax
movl %eax, %ecx
addl $-0xd, %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
addl $-0xd, %eax
sarl %eax
movl %eax, -0x2c(%rbp)
movl %r14d, %ebx
subl %eax, %ebx
cmovll %r14d, %eax
movslq %eax, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0xa260
testl %eax, %eax
cmovnel %eax, %ebx
movq -0x50(%rbp), %rdi
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rcx
testl %ebx, %ebx
je 0x3bb00
movq 0x18(%rcx), %rcx
movl %ebx, %eax
negl %eax
cmpb $0x0, (%rcx)
cmovel %ebx, %eax
jmp 0x3bb2b
xorl %eax, %eax
cmpw $0x2, 0x6(%rcx)
jb 0x3bb2b
movq -0x40(%rbp), %rsi
movq %r12, %rdx
movl -0x34(%rbp), %ecx
movq -0x48(%rbp), %r8
movl -0x38(%rbp), %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3bb8d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeSorterFlushThread
static void *vdbeSorterFlushThread(void *pCtx){
  SortSubtask *pTask = (SortSubtask*)pCtx;
  int rc;                         /* Return code */
  assert( pTask->bDone==0 );
  rc = vdbeSorterListToPMA(pTask, &pTask->list);
  pTask->bDone = 1;
  return SQLITE_INT_TO_PTR(rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %rsi
callq 0x3bbe3
movl $0x1, 0x8(%rbx)
cltq
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbePmaReaderIncrInit
static int vdbePmaReaderIncrInit(PmaReader *pReadr, int eMode){
  IncrMerger *pIncr = pReadr->pIncr;   /* Incremental merger */
  int rc = SQLITE_OK;                  /* Return code */
  if( pIncr ){
#if SQLITE_MAX_WORKER_THREADS>0
    assert( pIncr->bUseThread==0 || eMode==INCRINIT_TASK );
    if( pIncr->bUseThread ){
      void *pCtx = (void*)pReadr;
      rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx);
    }else
#endif
    {
      rc = vdbePmaReaderIncrMergeInit(pReadr, eMode);
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x3c103
movq %rdi, %rdx
cmpl $0x0, 0x20(%rax)
je 0x3c107
movq (%rax), %rdi
leaq 0xc04(%rip), %rsi       # 0x3cd01
popq %rbp
jmp 0x3bd52
xorl %eax, %eax
popq %rbp
retq
movq %rdx, %rdi
popq %rbp
jmp 0x3c10d
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeIncrPopulateThread
static void *vdbeIncrPopulateThread(void *pCtx){
  IncrMerger *pIncr = (IncrMerger*)pCtx;
  void *pRet = SQLITE_INT_TO_PTR( vdbeIncrPopulate(pIncr) );
  pIncr->pTask->bDone = 1;
  return pRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3c9d0
cltq
movq (%rbx), %rcx
movl $0x1, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbePmaReaderBgIncrInit
static void *vdbePmaReaderBgIncrInit(void *pCtx){
  PmaReader *pReader = (PmaReader*)pCtx;
  void *pRet = SQLITE_INT_TO_PTR(
                  vdbePmaReaderIncrMergeInit(pReader,INCRINIT_TASK)
               );
  pReader->pIncr->pTask->bDone = 1;
  return pRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x3c10d
cltq
movq 0x48(%rbx), %rcx
movq (%rcx), %rcx
movl $0x1, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: corruptSchema
static void corruptSchema(
  InitData *pData,     /* Initialization context */
  const char *zObj,    /* Object being parsed at the point of error */
  const char *zExtra   /* Error information */
){
  sqlite3 *db = pData->db;
  if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
    char *z;
    if( zObj==0 ) zObj = "?";
    z = sqlite3_mprintf("malformed database schema (%s)", zObj);
    if( z && zExtra ) z = sqlite3_mprintf("%z - %s", z, zExtra);
    sqlite3DbFree(db, *pData->pzErrMsg);
    *pData->pzErrMsg = z;
    if( z==0 ) db->mallocFailed = 1;
  }
  pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpb $0x0, 0x51(%r14)
jne 0x3cf89
testb $0x1, 0x2e(%r14)
jne 0x3cf89
movq %rdx, %r15
testq %rsi, %rsi
leaq 0x42c43(%rip), %rax     # 0x7fb6d
cmovneq %rsi, %rax
leaq 0x40ebc(%rip), %rdi     # 0x7ddf1
movq %rax, %rsi
xorl %eax, %eax
callq 0xa500
movq %rax, %r12
testq %rax, %rax
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x3cf69
leaq 0x40eb7(%rip), %rdi     # 0x7de10
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa500
movq %rax, %r12
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xb6df
movq 0x8(%rbx), %rax
movq %r12, (%rax)
testq %r12, %r12
jne 0x3cf89
movb $0x1, 0x51(%r14)
movl $0x7, %r15d
cmpb $0x0, 0x51(%r14)
jne 0x3cfbb
leaq 0x4053b(%rip), %rsi     # 0x7d4d8
leaq 0x401d9(%rip), %rcx     # 0x7d17d
movl $0xb, %r15d
movl $0xb, %edi
movl $0x1a906, %edx          # imm = 0x1A906
xorl %eax, %eax
callq 0xa4b0
movl %r15d, 0x14(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq