LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x3499d
testl %eax, %eax
jne 0x34842
movq (%r13), %r14
movq %r14, -0x30(%rbp)
movq 0x10(%rbx), %rax
movb 0x5c(%rax), %al
cmpb $0x2, %al
leaq 0x458(%rip), %rcx       # 0x34bba
leaq 0x54f(%rip), %rdx       # 0x34cb8
cmoveq %rcx, %rdx
cmpb $0x1, %al
leaq 0x32e(%rip), %rax       # 0x34aa4
cmovneq %rdx, %rax
movq %rax, 0x40(%rbx)
movl $0x200, %edi            # imm = 0x200
callq 0xe97d
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x3483f
leaq -0x30(%rbp), %r12
testq %r14, %r14
je 0x347fa
movq %r13, %r15
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x347b8
cmpq %r13, %r14
je 0x347be
movslq 0x8(%r14), %rax
addq %rax, %r13
jmp 0x347c1
movq 0x8(%r14), %r13
jmp 0x347c1
xorl %r13d, %r13d
andq $0x0, 0x8(%r14)
movq -0x38(%rbp), %r14
movq (%r14), %rdx
movq -0x30(%rbp), %rsi
testq %rdx, %rdx
je 0x347eb
movq %rbx, %rdi
movq %r12, %rcx
callq 0x349fd
andq $0x0, (%r14)
addq $0x8, %r14
jmp 0x347ca
movq %rsi, (%r14)
movq %r13, -0x30(%rbp)
movq %r13, %r14
movq %r15, %r13
jmp 0x34799
leaq -0x30(%rbp), %r12
andq $0x0, (%r12)
xorl %r14d, %r14d
movq -0x30(%rbp), %rsi
cmpq $0x40, %r14
je 0x34828
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %rdx
movq %rbx, %rdi
movq %r12, %rcx
callq 0x349fd
incq %r14
jmp 0x34806
movq %rsi, (%r13)
movq -0x38(%rbp), %rdi
callq 0xa828
movq 0x18(%rbx), %rax
movzbl 0x13(%rax), %eax
jmp 0x34842
pushq $0x7
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x349f0
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 0x2fb12
movq %rax, 0x18(%r14)
cmpq $0x0, (%r15)
je 0x349ed
movq 0x10(%r14), %rcx
movq 0x28(%rcx), %rcx
movzwl 0x6(%rcx), %ecx
movw %cx, 0x10(%rax)
movb $0x0, 0x13(%rax)
jmp 0x349f0
pushq $0x7
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, -0x38(%rbp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq -0x40(%rbp), %r13
andq $0x0, (%r13)
leaq -0x2c(%rbp), %rax
andl $0x0, (%rax)
leaq 0x10(%r15), %rbx
testq %r14, %r14
je 0x34a7f
testq %r15, %r15
je 0x34a7f
leaq 0x10(%r14), %rdx
movl (%r14), %ecx
movl (%r15), %r9d
movq %r12, %rdi
leaq -0x2c(%rbp), %rsi
movq %rbx, %r8
callq *0x40(%r12)
testl %eax, %eax
jg 0x34a6a
movq %r14, (%r13)
movq 0x8(%r14), %rax
addq $0x8, %r14
movq %r14, %r13
movq %rax, %r14
jmp 0x34a2f
movq %r15, (%r13)
movq %r15, %r13
movq 0x8(%r15), %r15
addq $0x8, %r13
andl $0x0, -0x2c(%rbp)
jmp 0x34a2b
testq %r14, %r14
cmovneq %r14, %r15
movq %r15, (%r13)
movq -0x40(%rbp), %rax
movq -0x38(%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_O2/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 $0x38, %rsp
movl %r9d, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movq %rdx, %r12
movq %rsi, -0x48(%rbp)
movq %rdi, -0x50(%rbp)
movzbl (%rdx), %r15d
movzbl (%r8), %r13d
movsbl 0x1(%rdx), %eax
testl %eax, %eax
jns 0x34c06
leaq 0x1(%r12), %rdi
leaq -0x54(%rbp), %rbx
movq %rbx, %rsi
movq %r8, %r14
callq 0x2eef1
movq %r14, %r8
movl (%rbx), %eax
addq %r12, %r15
addq %r8, %r13
addl $-0xd, %eax
pushq $0x2
popq %rbx
cltd
idivl %ebx
movl %eax, %r14d
movq %r8, -0x40(%rbp)
movsbl 0x1(%r8), %eax
testl %eax, %eax
jns 0x34c3c
movq -0x40(%rbp), %rax
leaq 0x1(%rax), %rdi
leaq -0x34(%rbp), %rsi
callq 0x2eef1
leaq -0x34(%rbp), %rax
movl (%rax), %eax
addl $-0xd, %eax
cltd
idivl %ebx
movl %r14d, %ebx
subl %eax, %ebx
cmovll %r14d, %eax
movslq %eax, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0xa2e0
testl %eax, %eax
cmovnel %eax, %ebx
movq -0x50(%rbp), %rdi
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rcx
testl %ebx, %ebx
je 0x34c7e
movq 0x18(%rcx), %rcx
movl %ebx, %eax
negl %eax
cmpb $0x0, (%rcx)
cmovel %ebx, %eax
jmp 0x34ca9
xorl %eax, %eax
cmpw $0x2, 0x6(%rcx)
jb 0x34ca9
movq -0x48(%rbp), %rsi
movq %r12, %rdx
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %r8
movl -0x30(%rbp), %r9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34d09
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34d5d
movl $0x1, 0x8(%rbx)
cltq
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35276
movq %rdi, %rdx
cmpl $0x0, 0x20(%rax)
je 0x3527a
movq (%rax), %rdi
leaq 0xad5(%rip), %rsi       # 0x35d45
popq %rbp
jmp 0x34e69
xorl %eax, %eax
popq %rbp
retq
movq %rdx, %rdi
popq %rbp
jmp 0x35280
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: vdbeIncrPopulate
static int vdbeIncrPopulate(IncrMerger *pIncr){
  int rc = SQLITE_OK;
  int rc2;
  i64 iStart = pIncr->iStartOff;
  SorterFile *pOut = &pIncr->aFile[1];
  SortSubtask *pTask = pIncr->pTask;
  MergeEngine *pMerger = pIncr->pMerger;
  PmaWriter writer;
  assert( pIncr->bEof==0 );

  vdbeSorterPopulateDebug(pTask, "enter");

  vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
  while( rc==SQLITE_OK ){
    int dummy;
    PmaReader *pReader = &pMerger->aReadr[ pMerger->aTree[1] ];
    int nKey = pReader->nKey;
    i64 iEof = writer.iWriteOff + writer.iBufEnd;

    /* Check if the output file is full or if the input has been exhausted.
    ** In either case exit the loop. */
    if( pReader->pFd==0 ) break;
    if( (iEof + nKey + sqlite3VarintLen(nKey))>(iStart + pIncr->mxSz) ) break;

    /* Write the next key to the output. */
    vdbePmaWriteVarint(&writer, nKey);
    vdbePmaWriteBlob(&writer, pReader->aKey, nKey);
    assert( pIncr->pMerger->pTask==pTask );
    rc = vdbeMergeEngineStep(pIncr->pMerger, &dummy);
  }

  rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof);
  if( rc==SQLITE_OK ) rc = rc2;
  vdbeSorterPopulateDebug(pTask, "exit");
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq %rdx, -0x40(%rbp)
movq 0x38(%rdi), %rdi
movq 0x10(%rax), %rax
movl 0xc(%rax), %edx
leaq -0x78(%rbp), %rsi
movq %rcx, -0x38(%rbp)
callq 0x3502f
xorl %r13d, %r13d
movq %rbx, -0x30(%rbp)
testl %r13d, %r13d
jne 0x35b8b
movq -0x40(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %r14
movslq 0x4(%rax), %rax
imulq $0x50, %rax, %r15
cmpq $0x0, 0x18(%r14,%r15)
je 0x35b8b
movslq 0x14(%r14,%r15), %r12
movslq -0x60(%rbp), %rax
movq -0x58(%rbp), %rbx
addq %r12, %rbx
addq %rax, %rbx
movq %r12, %rdi
callq 0x2f0b6
cltq
addq %rbx, %rax
movq -0x30(%rbp), %rbx
movslq 0x18(%rbx), %rcx
addq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jg 0x35b8b
addq %r15, %r14
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x35093
movq 0x28(%r14), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x350c3
movq 0x8(%rbx), %rdi
leaq -0x44(%rbp), %rsi
callq 0x35bd2
movl %eax, %r13d
jmp 0x35aff
addq $0x40, %rbx
leaq -0x78(%rbp), %rdi
movq %rbx, %rsi
callq 0x35166
testl %r13d, %r13d
cmovnel %r13d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35abd
cltq
movq (%rbx), %rcx
movl $0x1, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x35280
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_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
pushq $0x7
popq %r13
cmpb $0x0, 0x51(%r14)
jne 0x35fab
testb $0x1, 0x2e(%r14)
jne 0x35f96
movq %rdx, %r15
testq %rsi, %rsi
leaq 0x38c38(%rip), %rax     # 0x6eb6d
cmovneq %rsi, %rax
leaq 0x36eb1(%rip), %rdi     # 0x6cdf1
movq %rax, %rsi
xorl %eax, %eax
callq 0xa6c0
movq %rax, %r12
testq %rax, %rax
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x35f74
leaq 0x36eac(%rip), %rdi     # 0x6ce10
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xa6c0
movq %rax, %r12
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0xb856
movq 0x8(%rbx), %rax
movq %r12, (%rax)
testq %r12, %r12
je 0x35fa6
cmpb $0x0, 0x51(%r14)
jne 0x35fab
movl $0x1a906, %edi          # imm = 0x1A906
callq 0x1ec07
pushq $0xb
popq %r13
jmp 0x35fab
movb $0x1, 0x51(%r14)
movl %r13d, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3HashFind
SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey){
  HashElem *elem;    /* The element that matches key */
  unsigned int h;    /* A hash on key */

  assert( pH!=0 );
  assert( pKey!=0 );
  elem = findElementWithHash(pH, pKey, &h);
  return elem ? elem->data : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x4(%rbp), %rdx
callq 0x36193
testq %rax, %rax
je 0x3618b
movq 0x10(%rax), %rax
jmp 0x3618d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: findElementWithHash
static HashElem *findElementWithHash(
  const Hash *pH,     /* The pH to be searched */
  const char *pKey,   /* The key we are searching for */
  unsigned int *pHash /* Write the hash value here */
){
  HashElem *elem;                /* Used to loop thru the element list */
  int count;                     /* Number of elements left to test */
  unsigned int h;                /* The computed hash */

  if( pH->ht ){
    struct _ht *pEntry;
    h = strHash(pKey) % pH->htsize;
    pEntry = &pH->ht[h];
    elem = pEntry->chain;
    count = pEntry->count;
  }else{
    h = 0;
    elem = pH->first;
    count = pH->count;
  }
  *pHash = h;
  while( count-- ){
    assert( elem!=0 );
    if( sqlite3StrICmp(elem->pKey,pKey)==0 ){ 
      return elem;
    }
    elem = elem->next;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x361cc
movq %rbx, %rdi
callq 0x36207
xorl %edx, %edx
divl (%r15)
movq %rdx, %rax
shlq $0x4, %rax
addq %rax, %r12
movq %r12, %r15
jmp 0x361d2
leaq 0x4(%r15), %r12
xorl %edx, %edx
movl (%r12), %r12d
movq 0x8(%r15), %r15
movl %edx, (%r14)
subl $0x1, %r12d
jb 0x361f8
movq 0x18(%r15), %rdi
movq %rbx, %rsi
callq 0xa4f0
testl %eax, %eax
je 0x361fb
movq (%r15), %r15
jmp 0x361dd
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: strHash
static unsigned int strHash(const char *z){
  unsigned int h = 0;
  unsigned char c;
  while( (c = (unsigned char)*z++)!=0 ){
    h = (h<<3) ^ h ^ sqlite3UpperToLower[c];
  }
  return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x330fc(%rip), %rcx     # 0x69310
movzbl (%rdi), %edx
testq %rdx, %rdx
je 0x36232
incq %rdi
leal (,%rax,8), %esi
movzbl (%rdx,%rcx), %edx
xorl %eax, %esi
xorl %edx, %esi
movl %esi, %eax
jmp 0x36214
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3DefaultRowEst
SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
  /*                10,  9,  8,  7,  6 */
  LogEst aVal[] = { 33, 32, 30, 28, 26 };
  LogEst *a = pIdx->aiRowLogEst;
  int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
  int i;

  /* Set the first entry (number of rows in the index) to the estimated 
  ** number of rows in the table. Or 10, if the estimated number of rows 
  ** in the table is less than that.  */
  a[0] = pIdx->pTable->nRowLogEst;
  if( a[0]<33 ) a[0] = 33;        assert( 33==sqlite3LogEst(10) );

  /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
  ** 6 and each subsequent value (if any) is 5.  */
  memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
  for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
    a[i] = 23;                    assert( 23==sqlite3LogEst(5) );
  }

  assert( 0==sqlite3LogEst(1) );
  if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %rax
movzwl 0x5e(%rdi), %ecx
cmpw $0x5, %cx
pushq $0x5
popq %r12
cmovbl %ecx, %r12d
movzwl 0x42(%rax), %eax
cmpw $0x22, %ax
pushq $0x21
popq %rcx
cmovgel %eax, %ecx
movw %cx, (%r15)
leaq 0x2(%r15), %r14
leal (%r12,%r12), %edx
movl $0xffff, %r13d          # imm = 0xFFFF
andl %r13d, %edx
leaq 0x33581(%rip), %rsi     # 0x69808
movq %r14, %rdi
callq 0xa3b0
andl %r13d, %r12d
movzwl 0x5e(%rbx), %eax
cmpq %rax, %r12
jae 0x362a7
movw $0x17, (%r14,%r12,2)
incq %r12
jmp 0x36292
cmpb $0x0, 0x62(%rbx)
je 0x362b3
andw $0x0, (%r15,%rax,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: analysisLoader
static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
  analysisInfo *pInfo = (analysisInfo*)pData;
  Index *pIndex;
  Table *pTable;
  const char *z;

  assert( argc==3 );
  UNUSED_PARAMETER2(NotUsed, argc);

  if( argv==0 || argv[0]==0 || argv[2]==0 ){
    return 0;
  }
  pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase);
  if( pTable==0 ){
    return 0;
  }
  if( argv[1]==0 ){
    pIndex = 0;
  }else if( sqlite3_stricmp(argv[0],argv[1])==0 ){
    pIndex = sqlite3PrimaryKeyIndex(pTable);
  }else{
    pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
  }
  z = argv[2];

  if( pIndex ){
    tRowcnt *aiRowEst = 0;
    int nCol = pIndex->nKeyCol+1;
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
    /* Index.aiRowEst may already be set here if there are duplicate 
    ** sqlite_stat1 entries for this index. In that case just clobber
    ** the old data with the new instead of allocating a new array.  */
    if( pIndex->aiRowEst==0 ){
      pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
      if( pIndex->aiRowEst==0 ) pInfo->db->mallocFailed = 1;
    }
    aiRowEst = pIndex->aiRowEst;
#endif
    pIndex->bUnordered = 0;
    decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
    if( pIndex->pPartIdxWhere==0 ) pTable->nRowLogEst = pIndex->aiRowLogEst[0];
  }else{
    Index fakeIdx;
    fakeIdx.szIdxRow = pTable->szTabRow;
#ifdef SQLITE_ENABLE_COSTMULT
    fakeIdx.pTable = pTable;
#endif
    decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx);
    pTable->szTabRow = fakeIdx.szIdxRow;
  }

  return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x363b5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x363a9
cmpq $0x0, 0x10(%r14)
je 0x363a9
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rdx
callq 0x18a53
testq %rax, %rax
je 0x363a9
movq %rax, %rbx
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x36338
movq (%r14), %rdi
movq %r12, %rsi
callq 0xa4f0
testl %eax, %eax
je 0x3633e
movq (%r15), %rdi
movq 0x8(%r15), %rdx
movq %r12, %rsi
callq 0x35fe6
jmp 0x36346
movq 0x10(%r14), %rdi
jmp 0x3637e
movq %rbx, %rdi
callq 0x363b8
movq %rax, %r15
movq 0x10(%r14), %rdi
testq %rax, %rax
je 0x3637e
movzwl 0x5e(%r15), %esi
incl %esi
andb $-0x5, 0x63(%r15)
movq 0x10(%r15), %rdx
movq %r15, %rcx
callq 0x363de
cmpq $0x0, 0x48(%r15)
jne 0x363a9
movq 0x10(%r15), %rax
movzwl (%rax), %eax
movw %ax, 0x42(%rbx)
jmp 0x363a9
movzwl 0x44(%rbx), %eax
leaq -0x88(%rbp), %r14
movw %ax, 0x5c(%r14)
movq %rbx, %rdx
addq $0x42, %rdx
pushq $0x1
popq %rsi
movq %r14, %rcx
callq 0x363de
movzwl 0x5c(%r14), %eax
movw %ax, 0x44(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: freeIndex
static void freeIndex(sqlite3 *db, Index *p){
#ifndef SQLITE_OMIT_ANALYZE
  sqlite3DeleteIndexSamples(db, p);
#endif
  sqlite3ExprDelete(db, p->pPartIdxWhere);
  sqlite3ExprListDelete(db, p->aColExpr);
  sqlite3DbFree(db, p->zColAff);
  if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  sqlite3_free(p->aiRowEst);
#endif
  sqlite3DbFree(db, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
callq 0x367e7
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x36862
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xb856
testb $0x10, 0x63(%rbx)
je 0x367d8
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xb856
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb856
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: clearSelect
static void clearSelect(sqlite3 *db, Select *p, int bFree){
  while( p ){
    Select *pPrior = p->pPrior;
    sqlite3ExprListDelete(db, p->pEList);
    sqlite3SrcListDelete(db, p->pSrc);
    sqlite3ExprDelete(db, p->pWhere);
    sqlite3ExprListDelete(db, p->pGroupBy);
    sqlite3ExprDelete(db, p->pHaving);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pLimit);
    sqlite3ExprDelete(db, p->pOffset);
    sqlite3WithDelete(db, p->pWith);
    if( bFree ) sqlite3DbFree(db, p);
    p = pPrior;
    bFree = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
sete %r12b
testq %r14, %r14
je 0x36991
movq %r14, %r15
movq (%r14), %rsi
movq 0x50(%r14), %r14
movq %rbx, %rdi
callq 0x36862
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x3699a
movq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x367e7
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x36862
movq 0x40(%r15), %rsi
movq %rbx, %rdi
callq 0x367e7
movq 0x48(%r15), %rsi
movq %rbx, %rdi
callq 0x36862
movq 0x60(%r15), %rsi
movq %rbx, %rdi
callq 0x367e7
movq 0x68(%r15), %rsi
movq %rbx, %rdi
callq 0x367e7
movq 0x70(%r15), %rsi
movq %rbx, %rdi
callq 0x36a5e
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x368f3
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb856
xorl %r12d, %r12d
jmp 0x368f3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: checkAppendMsg
static void checkAppendMsg(
  IntegrityCk *pCheck,
  const char *zFormat,
  ...
){
  va_list ap;
  if( !pCheck->mxErr ) return;
  pCheck->mxErr--;
  pCheck->nErr++;
  va_start(ap, zFormat);
  if( pCheck->errMsg.nChar ){
    sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
  }
  if( pCheck->zPfx ){
    sqlite3XPrintf(&pCheck->errMsg, 0, pCheck->zPfx, pCheck->v1, pCheck->v2);
  }
  sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
  va_end(ap);
  if( pCheck->errMsg.accError==STRACCUM_NOMEM ){
    pCheck->mallocFailed = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x3752c
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0x375bd
movq %rsi, %r14
movq %rdi, %rbx
decl %eax
movl %eax, 0x1c(%rdi)
incl 0x20(%rdi)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x30(%rbp)
leaq 0x38(%rdi), %r15
cmpl $0x0, 0x50(%rdi)
je 0x37582
leaq 0x37b19(%rip), %rsi     # 0x6f090
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x19b35
movq 0x28(%rbx), %rdx
testq %rdx, %rdx
je 0x3759e
movl 0x30(%rbx), %ecx
movl 0x34(%rbx), %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3765e
pushq $0x1
popq %rsi
leaq -0x30(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xc52a
cmpb $0x1, 0x5c(%rbx)
jne 0x375bd
movl $0x1, 0x24(%rbx)
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: checkRef
static int checkRef(IntegrityCk *pCheck, Pgno iPage){
  if( iPage==0 ) return 1;
  if( iPage>pCheck->nPage ){
    checkAppendMsg(pCheck, "invalid page number %d", iPage);
    return 1;
  }
  if( getPageReferenced(pCheck, iPage) ){
    checkAppendMsg(pCheck, "2nd reference to page %d", iPage);
    return 1;
  }
  setPageReferenced(pCheck, iPage);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
testl %esi, %esi
je 0x3761b
movl %esi, %edx
cmpl %esi, 0x18(%rdi)
jae 0x375e8
leaq 0x35961(%rip), %rsi     # 0x6cf47
jmp 0x37614
movq 0x10(%rdi), %rax
movl %edx, %esi
shrl $0x3, %esi
movl %edx, %ecx
andb $0x7, %cl
movl %ebx, %r8d
shll %cl, %r8d
movzbl (%rax,%rsi), %ecx
movl %edx, %r9d
andl $0x7, %r9d
btl %r9d, %ecx
jae 0x37624
leaq 0x3594a(%rip), %rsi     # 0x6cf5e
xorl %eax, %eax
callq 0x374d3
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
orb %cl, %r8b
movb %r8b, (%rax,%rsi)
xorl %ebx, %ebx
jmp 0x3761b
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: growOpArray
static int growOpArray(Vdbe *v, int nOp){
  VdbeOp *pNew;
  Parse *p = v->pParse;

  /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
  ** more frequent reallocs and hence provide more opportunities for 
  ** simulated OOM faults.  SQLITE_TEST_REALLOC_STRESS is generally used
  ** during testing only.  With SQLITE_TEST_REALLOC_STRESS grow the op array
  ** by the minimum* amount required until the size reaches 512.  Normal
  ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
  ** size of the op array or add 1KB of space, whichever is smaller. */
#ifdef SQLITE_TEST_REALLOC_STRESS
  int nNew = (p->nOpAlloc>=512 ? p->nOpAlloc*2 : p->nOpAlloc+nOp);
#else
  int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
  UNUSED_PARAMETER(nOp);
#endif

  assert( nOp<=(1024/sizeof(Op)) );
  assert( nNew>=(p->nOpAlloc+nOp) );
  pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
  if( pNew ){
    p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
    p->nOpAlloc = p->szOpAlloc/sizeof(Op);
    v->aOp = pNew;
  }
  return (pNew ? SQLITE_OK : SQLITE_NOMEM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x30(%rdi), %r15
movslq 0x60(%r15), %rax
imulq $0x30, %rax, %rcx
testq %rax, %rax
movl $0x3f0, %edx            # imm = 0x3F0
cmovneq %rcx, %rdx
movq (%r15), %rdi
callq 0x19d92
testq %rax, %rax
je 0x386ba
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0x19b07
movl %eax, 0x64(%r15)
cltq
xorl %ecx, %ecx
pushq $0x18
popq %rsi
xorl %edx, %edx
divq %rsi
movl %eax, 0x60(%r15)
movq %r14, 0x8(%rbx)
jmp 0x386bd
pushq $0x7
popq %rcx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeGetOp
SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
  /* C89 specifies that the constant "dummy" will be initialized to all
  ** zeros, which is correct.  MSVC generates a warning, nevertheless. */
  static VdbeOp dummy;  /* Ignore the MSVC warning about no initializer */
  assert( p->magic==VDBE_MAGIC_INIT );
  if( addr<0 ){
    addr = p->nOp - 1;
  }
  assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
  if( p->db->mallocFailed ){
    return (VdbeOp*)&dummy;
  }else{
    return &p->aOp[addr];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jns 0x386d7
movl 0x3c(%rdi), %esi
decl %esi
movq (%rdi), %rax
cmpb $0x0, 0x51(%rax)
je 0x386e9
leaq 0x4cf01(%rip), %rax     # 0x855e8
jmp 0x386f4
movslq %esi, %rax
imulq $0x18, %rax, %rax
addq 0x8(%rdi), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3DbStrNDup
SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
  char *zNew;
  if( z==0 ){
    return 0;
  }
  assert( (n&0x7fffffff)==n );
  zNew = sqlite3DbMallocRaw(db, n+1);
  if( zNew ){
    memcpy(zNew, z, (size_t)n);
    zNew[n] = 0;
  }
  return zNew;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x38731
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x1(%rdx), %rsi
callq 0x132c5
testq %rax, %rax
je 0x38731
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xa3b0
movb $0x0, (%r14,%rbx)
jmp 0x38734
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: addModuleArgument
static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
  int nBytes = sizeof(char *)*(2+pTable->nModuleArg);
  char **azModuleArg;
  azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
  if( azModuleArg==0 ){
    sqlite3DbFree(db, zArg);
  }else{
    int i = pTable->nModuleArg++;
    azModuleArg[i] = zArg;
    azModuleArg[i+1] = 0;
    pTable->azModuleArg = azModuleArg;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4c(%rsi), %eax
leal 0x10(,%rax,8), %eax
movq 0x50(%rsi), %rsi
movslq %eax, %rdx
callq 0x19d92
testq %rax, %rax
je 0x388f5
movslq 0x4c(%r14), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x4c(%r14)
movq %rbx, (%rax,%rcx,8)
andq $0x0, 0x8(%rax,%rcx,8)
movq %rax, 0x50(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb856
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VtabEponymousTableClear
SQLITE_PRIVATE void sqlite3VtabEponymousTableClear(sqlite3 *db, Module *pMod){
  Table *pTab = pMod->pEpoTab;
  if( pTab!=0 ){
    sqlite3DeleteColumnNames(db, pTab);
    sqlite3VtabClear(db, pTab);
    sqlite3DbFree(db, pTab);
    pMod->pEpoTab = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rsi), %r14
testq %r14, %r14
je 0x38946
movq %rsi, %rbx
movq %rdi, %r15
movq %r14, %rsi
callq 0x38951
movq %r15, %rdi
movq %r14, %rsi
callq 0x389d9
movq %r15, %rdi
movq %r14, %rsi
callq 0xb856
andq $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VtabClear
SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){
  if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
  if( p->azModuleArg ){
    int i;
    for(i=0; i<p->nModuleArg; i++){
      if( i!=1 ) sqlite3DbFree(db, p->azModuleArg[i]);
    }
    sqlite3DbFree(db, p->azModuleArg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x389f8
cmpq $0x0, 0x328(%rbx)
jne 0x38a02
xorl %edi, %edi
movq %r14, %rsi
callq 0x37f86
cmpq $0x0, 0x50(%r14)
je 0x38a46
xorl %r15d, %r15d
movslq 0x4c(%r14), %rax
cmpq %rax, %r15
jge 0x38a30
cmpq $0x1, %r15
je 0x38a2b
movq 0x50(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xb856
incq %r15
jmp 0x38a0c
movq 0x50(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb856
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: yy_shift
static void yy_shift(
  yyParser *yypParser,          /* The parser to be shifted */
  int yyNewState,               /* The new state to shift in */
  int yyMajor,                  /* The major token to shift in */
  YYMINORTYPE *yypMinor         /* Pointer to the minor token to shift in */
){
  yyStackEntry *yytos;
  yypParser->yyidx++;
#ifdef YYTRACKMAXSTACKDEPTH
  if( yypParser->yyidx>yypParser->yyidxMax ){
    yypParser->yyidxMax = yypParser->yyidx;
  }
#endif
#if YYSTACKDEPTH>0 
  if( yypParser->yyidx>=YYSTACKDEPTH ){
    yyStackOverflow(yypParser, yypMinor);
    return;
  }
#else
  if( yypParser->yyidx>=yypParser->yystksz ){
    yyGrowStack(yypParser);
    if( yypParser->yyidx>=yypParser->yystksz ){
      yyStackOverflow(yypParser, yypMinor);
      return;
    }
  }
#endif
  yytos = &yypParser->yystack[yypParser->yyidx];
  yytos->stateno = (YYACTIONTYPE)yyNewState;
  yytos->major = (YYCODETYPE)yyMajor;
  yytos->minor = *yypMinor;
  yyTraceShift(yypParser, yyNewState);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rax
leaq 0x1(%rax), %rdi
movl %edi, (%rbx)
cmpq $0x63, %rax
jl 0x393b4
movq 0x8(%rbx), %r14
movl %eax, (%rbx)
testl %eax, %eax
js 0x3939d
movq %rbx, %rdi
callq 0x3d37c
movl (%rbx), %eax
jmp 0x3938d
leaq 0x3450d(%rip), %rsi     # 0x6d8b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x1357a
movq %r14, 0x8(%rbx)
jmp 0x393d2
shlq $0x5, %rdi
movw %si, 0x10(%rbx,%rdi)
movb %dl, 0x12(%rbx,%rdi)
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rbx,%rdi)
movq 0x10(%rcx), %rax
movq %rax, 0x28(%rbx,%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PExpr
SQLITE_PRIVATE Expr *sqlite3PExpr(
  Parse *pParse,          /* Parsing context */
  int op,                 /* Expression opcode */
  Expr *pLeft,            /* Left operand */
  Expr *pRight,           /* Right operand */
  const Token *pToken     /* Argument token */
){
  Expr *p;
  if( op==TK_AND && pParse->nErr==0 ){
    /* Take advantage of short-circuit false optimization for AND */
    p = sqlite3ExprAnd(pParse->db, pLeft, pRight);
  }else{
    p = sqlite3ExprAlloc(pParse->db, op & TKFLG_MASK, pToken, 1);
    sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
  }
  if( p ) {
    sqlite3ExprCheckHeight(pParse, p->nHeight);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x48, %esi
jne 0x3e38b
cmpl $0x0, 0x4c(%rbx)
je 0x3e3cf
movq (%rbx), %rdi
movzbl %sil, %esi
pushq $0x1
popq %rcx
movq %r8, %rdx
callq 0x4ee54
movq %rax, %r12
movq (%rbx), %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x523de
testq %r12, %r12
je 0x3e3c3
movl 0x28(%r12), %esi
movq %rbx, %rdi
callq 0x4f167
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x52262
movq %rax, %r12
jmp 0x3e3b1
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3SrcListIndexedBy
SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
  assert( pIndexedBy!=0 );
  if( p && ALWAYS(p->nSrc>0) ){
    struct SrcList_item *pItem = &p->a[p->nSrc-1];
    assert( pItem->fg.notIndexed==0 );
    assert( pItem->fg.isIndexedBy==0 );
    assert( pItem->fg.isTabFunc==0 );
    if( pIndexedBy->n==1 && !pIndexedBy->z ){
      /* A "NOT INDEXED" clause was supplied. See parse.y 
      ** construct "indexed_opt" for details. */
      pItem->fg.notIndexed = 1;
    }else{
      pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
      pItem->fg.isIndexedBy = (pItem->u1.zIndexedBy!=0);
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x432e7
movl (%rsi), %eax
testl %eax, %eax
jle 0x432e7
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
decl %eax
imulq $0x70, %rax, %rax
leaq (%rsi,%rax), %rbx
addq $0x8, %rbx
cmpl $0x1, 0x8(%rdx)
jne 0x432c0
cmpq $0x0, (%rdx)
je 0x432e8
movq (%rdi), %rdi
movq %rdx, %rsi
callq 0x4e80c
testq %rax, %rax
setne %cl
movq %rax, 0x60(%rbx)
movb 0x3d(%rbx), %al
addb %cl, %cl
andb $-0x3, %al
orb %cl, %al
movb %al, 0x3d(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
orb $0x1, 0x3d(%rbx)
jmp 0x432e1
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ExprFunction
SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
  Expr *pNew;
  sqlite3 *db = pParse->db;
  assert( pToken );
  pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
  if( pNew==0 ){
    sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
    return 0;
  }
  pNew->x.pList = pList;
  assert( !ExprHasProperty(pNew, EP_xIsSelect) );
  sqlite3ExprSetHeightAndFlags(pParse, pNew);
  return pNew;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r12
pushq $0x1
popq %rcx
movq %r12, %rdi
movl $0x97, %esi
callq 0x4ee54
movq %rax, %r14
testq %rax, %rax
je 0x4717a
movq %rbx, 0x20(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x472c4
jmp 0x47185
movq %r12, %rdi
movq %rbx, %rsi
callq 0x36862
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: binaryToUnaryIfNull
static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
    sqlite3 *db = pParse->db;
    if( pY && pA && pY->op==TK_NULL ){
      pA->op = (u8)op;
      sqlite3ExprDelete(db, pA->pRight);
      pA->pRight = 0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %dl
orb %al, %dl
jne 0x47278
cmpb $0x65, (%rsi)
jne 0x47278
movq (%rdi), %rdi
movb %cl, (%rbx)
movq 0x18(%rbx), %rsi
callq 0x367e7
andq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3GetVdbe
SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
  Vdbe *v = pParse->pVdbe;
  if( v==0 ){
    v = pParse->pVdbe = sqlite3VdbeCreate(pParse);
    if( v ) sqlite3VdbeAddOp0(v, OP_Init);
    if( pParse->pToplevel==0
     && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
    ){
      pParse->okConstFactor = 1;
    }

  }
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
jne 0x49fd9
movq %rdi, %r14
callq 0x136af
movq %rax, %rbx
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x49fc1
movq %rbx, %rdi
movl $0x9f, %esi
callq 0x4a011
cmpq $0x0, 0x1c0(%r14)
jne 0x49fd9
movq (%r14), %rax
testb $0x8, 0x4c(%rax)
jne 0x49fd9
movb $0x1, 0x23(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ExprCode
SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
  int inReg;

  assert( target>0 && target<=pParse->nMem );
  if( pExpr && pExpr->op==TK_REGISTER ){
    sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
  }else{
    inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
    assert( pParse->pVdbe!=0 || pParse->db->mallocFailed );
    if( inReg!=target && pParse->pVdbe ){
      sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
je 0x4a09f
cmpb $-0x63, (%rsi)
jne 0x4a09f
movq 0x10(%r14), %rdi
movl 0x2c(%rsi), %edx
pushq $0x1f
popq %rsi
jmp 0x4a0bb
movq %r14, %rdi
movl %ebx, %edx
callq 0x4a69e
cmpl %ebx, %eax
je 0x4a0c6
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x4a0c6
pushq $0x20
popq %rsi
movl %eax, %edx
movl %ebx, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x4a1ab
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3KeyInfoOfIndex
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
  int i;
  int nCol = pIdx->nColumn;
  int nKey = pIdx->nKeyCol;
  KeyInfo *pKey;
  if( pParse->nErr ) return 0;
  if( pIdx->uniqNotNull ){
    pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
  }else{
    pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
  }
  if( pKey ){
    assert( sqlite3KeyInfoIsWriteable(pKey) );
    for(i=0; i<nCol; i++){
      const char *zColl = pIdx->azColl[i];
      pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
                        sqlite3LocateCollSeq(pParse, zColl);
      pKey->aSortOrder[i] = pIdx->aSortOrder[i];
    }
    if( pParse->nErr ){
      sqlite3KeyInfoUnref(pKey);
      pKey = 0;
    }
  }
  return pKey;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x4c(%rdi)
je 0x4a2dc
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x60(%rsi), %r12d
testb $0x8, 0x63(%rsi)
movq (%rdi), %rdi
jne 0x4a2f7
movl %r12d, %esi
xorl %edx, %edx
jmp 0x4a301
movzwl 0x5e(%r14), %esi
movl %r12d, %edx
subl %esi, %edx
callq 0x4a36a
movq %rax, %r15
testq %rax, %rax
je 0x4a2c7
movl %r12d, %r12d
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x4a353
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rsi
leaq 0x1f438(%rip), %rax     # 0x69760
cmpq %rax, %rsi
je 0x4a337
movq %rbx, %rdi
callq 0x4a3ce
jmp 0x4a339
xorl %eax, %eax
movq %rax, 0x20(%r15,%r13,8)
movq 0x38(%r14), %rax
movb (%rax,%r13), %al
movq 0x18(%r15), %rcx
movb %al, (%rcx,%r13)
incq %r13
jmp 0x4a314
cmpl $0x0, 0x4c(%rbx)
je 0x4a2ca
movq %r15, %rdi
callq 0x24d28
jmp 0x4a2c7
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: codeInteger
static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
  Vdbe *v = pParse->pVdbe;
  if( pExpr->flags & EP_IntValue ){
    int i = pExpr->u.iValue;
    assert( i>=0 );
    if( negFlag ) i = -i;
    sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
  }else{
    int c;
    i64 value;
    const char *z = pExpr->u.zToken;
    assert( z!=0 );
    c = sqlite3DecOrHexToI64(z, &value);
    if( c==0 || (c==2 && negFlag) ){
      if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
      sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64);
    }else{
#ifdef SQLITE_OMIT_FLOATING_POINT
      sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
#else
#ifndef SQLITE_OMIT_HEX_INTEGER
      if( sqlite3_strnicmp(z,"0x",2)==0 ){
        sqlite3ErrorMsg(pParse, "hex literal too big: %s", z);
      }else
#endif
      {
        codeReal(v, z, negFlag, iMem);
      }
#endif
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r15d
movq 0x10(%rdi), %r14
testb $0x4, 0x5(%rsi)
jne 0x4b56e
movq %rdi, %r12
movq 0x8(%rsi), %r13
leaq -0x30(%rbp), %rsi
movq %r13, %rdi
callq 0x19899
testl %eax, %eax
je 0x4b596
cmpl $0x2, %eax
sete %cl
testl %r15d, %r15d
setne %dl
testb %cl, %dl
jne 0x4b59b
leaq 0x22576(%rip), %rsi     # 0x6dab3
pushq $0x2
popq %rdx
movq %r13, %rdi
callq 0xa730
testl %eax, %eax
je 0x4b5da
movq %r14, %rdi
movq %r13, %rsi
movl %r15d, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b5fc
movl 0x8(%rsi), %eax
movl %eax, %edx
negl %edx
testl %r15d, %r15d
cmovel %eax, %edx
pushq $0x17
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4a1ab
testl %r15d, %r15d
je 0x4b5b6
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
cmpl $0x2, %eax
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
pushq $0x18
popq %rsi
leaq -0x30(%rbp), %rcx
pushq $-0xd
popq %r8
movq %r14, %rdi
movl %ebx, %edx
callq 0x4ce46
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x224d5(%rip), %rsi     # 0x6dab6
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1357a
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeMakeLabel
SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *v){
  Parse *p = v->pParse;
  int i = p->nLabel++;
  assert( v->magic==VDBE_MAGIC_INIT );
  if( (i & (i-1))==0 ){
    p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel, 
                                       (i*2+1)*sizeof(p->aLabel[0]));
  }
  if( p->aLabel ){
    p->aLabel[i] = -1;
  }
  return ADDR(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x30(%rdi), %r14
movslq 0x7c(%r14), %rbx
leal 0x1(%rbx), %eax
movl %eax, 0x7c(%r14)
leal -0x1(%rbx), %eax
testl %eax, %ebx
jne 0x4b9ff
movq (%r14), %rdi
movq 0x80(%r14), %rsi
leaq 0x4(,%rbx,8), %rdx
callq 0x2684f
movq %rax, 0x80(%r14)
jmp 0x4ba06
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x4ba0f
orl $-0x1, (%rax,%rbx,4)
notl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq