LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x3d1ee
movb (%rbx), %r9b
testb %r9b, %r9b
je 0x3d1f6
leaq 0x1(%rbx), %rdx
xorl %r10d, %r10d
leaq 0x3d149(%rip), %r8      # 0x7a310
leal (,%r10,8), %eax
movzbl %r9b, %r9d
movzbl (%r9,%r8), %r9d
xorl %r10d, %eax
xorl %r9d, %eax
movb (%rdx), %r9b
incq %rdx
movl %eax, %r10d
testb %r9b, %r9b
jne 0x3d1c7
jmp 0x3d1f8
leaq 0x4(%rdi), %rsi
xorl %edx, %edx
jmp 0x3d209
xorl %eax, %eax
xorl %edx, %edx
divl (%rdi)
movq %rdx, %rax
shlq $0x4, %rax
addq %rax, %rsi
movq %rsi, %rdi
movl (%rsi), %r15d
movq 0x8(%rdi), %r14
movl %edx, (%rcx)
testl %r15d, %r15d
je 0x3d22f
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0xa3f0
testl %eax, %eax
je 0x3d232
movq (%r14), %r14
decl %r15d
jne 0x3d217
xorl %r14d, %r14d
movq %r14, %rax
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: 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), %r14
movq 0x18(%rdi), %rax
movzwl 0x5e(%rdi), %r15d
cmpw $0x5, %r15w
movl $0x5, %r12d
movl %r15d, %r13d
cmovael %r12d, %r13d
movzwl 0x42(%rax), %eax
cmpw $0x22, %ax
movl $0x21, %ecx
cmovgel %eax, %ecx
movw %cx, (%r14)
leaq 0x2(%r14), %rdi
movl %r13d, %eax
addl %r13d, %eax
movzwl %ax, %edx
leaq 0x3d580(%rip), %rsi     # 0x7a818
callq 0xa310
movzwl 0x5e(%rbx), %eax
cmpw %ax, %r13w
jae 0x3d2c8
cmpw $0x5, %r15w
cmovbl %r15d, %r12d
movzwl %r12w, %ecx
movw $0x17, 0x2(%r14,%rcx,2)
incq %rcx
movzwl 0x5e(%rbx), %eax
cmpq %rax, %rcx
jb 0x3d2b4
cmpb $0x0, 0x62(%rbx)
je 0x3d2d8
movzwl %ax, %eax
movw $0x0, (%r14,%rax,2)
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: 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 0x3d3d5
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 0x3d3c9
cmpq $0x0, 0x10(%r14)
je 0x3d3c9
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rdx
callq 0x1abce
testq %rax, %rax
je 0x3d3c9
movq %rax, %rbx
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x3d364
movq (%r14), %rdi
movq %r12, %rsi
callq 0xa3f0
testl %eax, %eax
je 0x3d3d8
movq (%r15), %rdi
movq 0x8(%r15), %rdx
movq %r12, %rsi
callq 0x3cfc8
movq %rax, %r15
jmp 0x3d367
xorl %r15d, %r15d
movq 0x10(%r14), %rdi
testq %r15, %r15
je 0x3d39c
movzwl 0x5e(%r15), %esi
incl %esi
andb $-0x5, 0x63(%r15)
movq 0x10(%r15), %rdx
movq %r15, %rcx
callq 0x3d3f5
cmpq $0x0, 0x48(%r15)
jne 0x3d3c9
movq 0x10(%r15), %rax
movzwl (%rax), %eax
movw %ax, 0x42(%rbx)
jmp 0x3d3c9
movzwl 0x44(%rbx), %eax
leaq -0x88(%rbp), %r14
movw %ax, 0x5c(%r14)
movq %rbx, %rdx
addq $0x42, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x3d3f5
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
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x3d367
movb 0x63(%r15), %al
andb $0x3, %al
cmpb $0x2, %al
je 0x3d367
movq 0x28(%r15), %r15
jmp 0x3d3dc
// File: /workspace/github_c_makefile_star2_O1/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 0x3d8f7
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x3d971
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0xb6df
testb $0x10, 0x63(%rbx)
je 0x3d8e8
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xb6df
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb6df
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x3da99
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
sete %r15b
movq (%r14), %rsi
movq 0x50(%r14), %r12
movq %rbx, %rdi
callq 0x3d971
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3da9a
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x3d8f7
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3d971
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x3d8f7
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x3d971
movq 0x60(%r14), %rsi
movq %rbx, %rdi
callq 0x3d8f7
movq 0x68(%r14), %rsi
movq %rbx, %rdi
callq 0x3d8f7
movq 0x70(%r14), %rsi
movq %rbx, %rdi
callq 0x3db65
testb $0x1, %r15b
jne 0x3da82
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb6df
xorl %r15d, %r15d
movq %r12, %r14
testq %r12, %r12
jne 0x3da02
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: 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 0x3e710
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 0x3e7bd
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 0x3e780
movl 0x50(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl 0x54(%rbx), %ecx
jae 0x3e76c
movl %ecx, 0x50(%rbx)
movq 0x48(%rbx), %rcx
movb $0xa, (%rcx,%rax)
jmp 0x3e780
leaq 0x4191d(%rip), %rsi     # 0x80090
movq %r15, %rdi
movl $0x1, %edx
callq 0x1be64
movq 0x28(%rbx), %rdx
testq %rdx, %rdx
je 0x3e79c
movl 0x30(%rbx), %ecx
movl 0x34(%rbx), %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3e833
leaq -0x30(%rbp), %rcx
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xc3ef
cmpb $0x1, 0x5c(%rbx)
jne 0x3e7bd
movl $0x1, 0x24(%rbx)
addq $0xc8, %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: 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
movl $0x1, %ebx
testl %esi, %esi
je 0x3e81f
movl %esi, %edx
cmpl %esi, 0x18(%rdi)
jae 0x3e7ea
leaq 0x3f75f(%rip), %rsi     # 0x7df47
jmp 0x3e818
movq 0x10(%rdi), %rax
movl %edx, %esi
shrl $0x3, %esi
movzbl (%rax,%rsi), %r8d
movl %edx, %ecx
andb $0x7, %cl
movl $0x1, %r9d
shll %cl, %r9d
movl %edx, %ecx
andl $0x7, %ecx
btl %ecx, %r8d
jae 0x3e828
leaq 0x3f746(%rip), %rsi     # 0x7df5e
xorl %eax, %eax
callq 0x3e6b7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
orb %r8b, %r9b
movb %r9b, (%rax,%rsi)
xorl %ebx, %ebx
jmp 0x3e81f
// File: /workspace/github_c_makefile_star2_O1/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
movq %rax, %rcx
shlq $0x4, %rcx
testq %rax, %rax
leaq (%rcx,%rcx,2), %rax
movl $0x3f0, %edx            # imm = 0x3F0
cmovneq %rax, %rdx
movq (%r15), %rdi
callq 0x1bffd
testq %rax, %rax
je 0x3fbd8
movq %rax, %r14
movq (%r15), %rax
testq %rax, %rax
je 0x3fbac
cmpq %r14, 0x170(%rax)
ja 0x3fbac
cmpq %r14, 0x178(%rax)
jbe 0x3fbac
movzwl 0x150(%rax), %eax
jmp 0x3fbb5
movq %r14, %rdi
callq *0x537ab(%rip)          # 0x93360
movl %eax, 0x64(%r15)
cltq
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
movl %edx, 0x60(%r15)
movq %r14, 0x8(%rbx)
xorl %eax, %eax
jmp 0x3fbdd
movl $0x7, %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: 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 0x1bffd
testq %rax, %rax
je 0x3fda5
movslq 0x4c(%r14), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x4c(%r14)
movq %rbx, (%rax,%rcx,8)
movq $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 0xb6df
// File: /workspace/github_c_makefile_star2_O1/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 0x3fdf9
movq %rsi, %rbx
movq %rdi, %r15
movq %r14, %rsi
callq 0x3fe04
movq %r15, %rdi
movq %r14, %rsi
callq 0x3fe91
movq %r15, %rdi
movq %r14, %rsi
callq 0xb6df
movq $0x0, 0x20(%rbx)
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: 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 0x3feb0
cmpq $0x0, 0x328(%rbx)
jne 0x3fef5
movq 0x58(%r14), %rax
movq $0x0, 0x58(%r14)
testq %rax, %rax
je 0x3fef5
movq (%rax), %rdx
movq 0x28(%rax), %rcx
testq %rdx, %rdx
je 0x3fee1
movq 0x1d0(%rdx), %rsi
movq %rsi, 0x28(%rax)
movq %rax, 0x1d0(%rdx)
jmp 0x3feed
movq %rax, 0x58(%r14)
movq $0x0, 0x28(%rax)
movq %rcx, %rax
testq %rcx, %rcx
jne 0x3fec1
cmpq $0x0, 0x50(%r14)
je 0x3ff3e
cmpl $0x0, 0x4c(%r14)
jle 0x3ff28
xorl %r15d, %r15d
cmpq $0x1, %r15
je 0x3ff1c
movq 0x50(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xb6df
incq %r15
movslq 0x4c(%r14), %rax
cmpq %rax, %r15
jl 0x3ff06
movq 0x50(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb6df
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: 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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %rax
leaq 0x1(%rax), %rdi
movl %edi, (%rbx)
cmpq $0x63, %rax
jl 0x40ab7
movq 0x8(%rbx), %r14
movl %eax, (%rbx)
leaq 0x10(%rbx), %r15
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
movl %eax, %eax
shlq $0x5, %rax
leaq (%r15,%rax), %rdx
addq $0x8, %rdx
movzbl -0x6(%rdx), %esi
movq %rbx, %rdi
callq 0x4279b
movl (%rbx), %eax
testl %eax, %eax
jns 0x40a7b
leaq 0x3de0a(%rip), %rsi     # 0x7e8b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x14804
movq %r14, 0x8(%rbx)
jmp 0x40ad5
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)
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: sqlite3AddColumn
SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName){
  Table *p;
  int i;
  char *z;
  Column *pCol;
  sqlite3 *db = pParse->db;
  if( (p = pParse->pNewTable)==0 ) return;
#if SQLITE_MAX_COLUMN
  if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
    return;
  }
#endif
  z = sqlite3NameFromToken(db, pName);
  if( z==0 ) return;
  for(i=0; i<p->nCol; i++){
    if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
      sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
      sqlite3DbFree(db, z);
      return;
    }
  }
  if( (p->nCol & 0x7)==0 ){
    Column *aNew;
    aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
    if( aNew==0 ){
      sqlite3DbFree(db, z);
      return;
    }
    p->aCol = aNew;
  }
  pCol = &p->aCol[p->nCol];
  memset(pCol, 0, sizeof(p->aCol[0]));
  pCol->zName = z;
  sqlite3ColumnPropertiesFromName(p, pCol);
 
  /* If there is no type specified, columns have the default affinity
  ** 'BLOB'. If there is a type specified, then sqlite3AddColumnType() will
  ** be called next to set pCol->affinity correctly.
  */
  pCol->affinity = SQLITE_AFF_BLOB;
  pCol->szEst = 1;
  p->nCol++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x220(%rdi), %r12
testq %r12, %r12
je 0x43d6e
movq %rdi, %r15
movq (%rdi), %rbx
movswl 0x3e(%r12), %eax
cmpl %eax, 0x70(%rbx)
jle 0x43ccf
movq %rbx, %rdi
callq 0x560d9
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x43d6e
movq %rbx, -0x40(%rbp)
movswl 0x3e(%r12), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
jle 0x43c93
movq 0x8(%r12), %r13
movl -0x2c(%rbp), %eax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r14
xorl %ebx, %ebx
movq (%r13,%rbx), %rsi
movq -0x38(%rbp), %rdi
callq 0xa3f0
testl %eax, %eax
je 0x43cf2
addq $0x30, %rbx
cmpq %rbx, %r14
jne 0x43c78
movl -0x2c(%rbp), %eax
testb $0x7, %al
movq -0x40(%rbp), %rbx
jne 0x43d35
cltq
movq 0x8(%r12), %rsi
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
addq $0x180, %rdx            # imm = 0x180
movq %rbx, %rdi
callq 0x1bffd
movq %rax, %r15
testq %rax, %rax
je 0x43d24
movq %r15, 0x8(%r12)
jmp 0x43d30
movq (%r12), %rdx
leaq 0x3b67b(%rip), %rsi     # 0x7f355
movq %r15, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14804
leaq 0x3b673(%rip), %rsi     # 0x7f36c
movq %r15, %rdi
movq -0x38(%rbp), %rbx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x14804
movq -0x40(%rbp), %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb6df
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0xb6df
testq %r15, %r15
je 0x43d6e
movq 0x8(%r12), %rax
movswq 0x3e(%r12), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rcx)
movups %xmm0, 0x20(%rax,%rcx)
movups %xmm0, 0x10(%rax,%rcx)
movq -0x38(%rbp), %rdx
movq %rdx, (%rax,%rcx)
movw $0x141, 0x29(%rax,%rcx) # imm = 0x141
incw 0x3e(%r12)
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: sqlite3AddColumnType
SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
  Table *p;
  Column *pCol;

  p = pParse->pNewTable;
  if( p==0 || NEVER(p->nCol<1) ) return;
  pCol = &p->aCol[p->nCol-1];
  assert( pCol->zType==0 || CORRUPT_DB );
  sqlite3DbFree(pParse->db, pCol->zType);
  pCol->zType = sqlite3NameFromToken(pParse->db, pType);
  pCol->affinity = sqlite3AffinityType(pCol->zType, &pCol->szEst);
}

// Assembly:
movq 0x220(%rdi), %rax
testq %rax, %rax
je 0x43ded
movswq 0x3e(%rax), %rcx
testq %rcx, %rcx
jle 0x43ded
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rax), %rax
decl %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rdi), %rdi
leaq (%rax,%rcx), %r15
addq $0x2a, %r15
movq -0x12(%r15), %rsi
callq 0xb6df
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x560d9
movq %rax, -0x12(%r15)
movq %rax, %rdi
movq %r15, %rsi
callq 0x524cd
movb %al, -0x1(%r15)
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: 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, %r15
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x48, %esi
jne 0x43f47
cmpl $0x0, 0x4c(%rbx)
je 0x43f9d
movq (%rbx), %rdi
movzbl %sil, %esi
movq %r8, %rdx
movl $0x1, %ecx
callq 0x56afe
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x5a829
testq %r14, %r14
je 0x43f91
movq (%rbx), %rax
movl 0x74(%rax), %edx
cmpl 0x28(%r14), %edx
jge 0x43f91
leaq 0x3ad7e(%rip), %rsi     # 0x7ed05
movq %rbx, %rdi
xorl %eax, %eax
callq 0x14804
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5a64c
movq %rax, %r14
jmp 0x43f6f
// File: /workspace/github_c_makefile_star2_O1/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 0x47851
movl (%rsi), %eax
testl %eax, %eax
jle 0x47851
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 0x4782a
cmpq $0x0, (%rdx)
je 0x47852
movq (%rdi), %rdi
movq %rdx, %rsi
callq 0x560d9
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 0x4784b
// File: /workspace/github_c_makefile_star2_O1/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
movq %r12, %rdi
movl $0x97, %esi
movl $0x1, %ecx
callq 0x56afe
testq %rax, %rax
je 0x4b6be
movq %rax, %r14
movq %rbx, 0x20(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x4b713
jmp 0x4b6cc
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3d971
xorl %r14d, %r14d
movq %r14, %rax
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: 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 0x4b70c
cmpb $0x65, (%rsi)
jne 0x4b70c
movq (%rdi), %rdi
movb %cl, (%rbx)
movq 0x18(%rbx), %rsi
callq 0x3d8f7
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3TriggerInsertStep
SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(
  sqlite3 *db,        /* The database connection */
  Token *pTableName,  /* Name of the table into which we insert */
  IdList *pColumn,    /* List of columns in pTableName to insert into */
  Select *pSelect,    /* A SELECT statement that supplies values */
  u8 orconf           /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
){
  TriggerStep *pTriggerStep;

  assert(pSelect != 0 || db->mallocFailed);

  pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName);
  if( pTriggerStep ){
    pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
    pTriggerStep->pIdList = pColumn;
    pTriggerStep->orconf = orconf;
  }else{
    sqlite3IdListDelete(db, pColumn);
  }
  sqlite3SelectDelete(db, pSelect);

  return pTriggerStep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %r14
movl $0x6c, %esi
callq 0x70c9a
movq %rax, %r15
movq %r14, %rdi
testq %rax, %rax
je 0x4f458
movq %rbx, %rsi
movl $0x1, %edx
callq 0x54d2a
movq %rax, 0x10(%r15)
movq %r12, 0x30(%r15)
movb %r13b, 0x1(%r15)
jmp 0x4f460
movq %r12, %rsi
callq 0x3dbd2
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x3d9e2
movq %r15, %rax
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: 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 0x5080f
movq %rdi, %r14
callq 0x14939
movq %rax, %rbx
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x507f7
movq %rbx, %rdi
movl $0x9f, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3fa9e
cmpq $0x0, 0x1c0(%r14)
jne 0x5080f
movq (%r14), %rax
testb $0x8, 0x4c(%rax)
jne 0x5080f
movb $0x1, 0x23(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x50ab1
cmpb $-0x63, (%rsi)
jne 0x50ab1
movq 0x10(%r14), %rdi
movl 0x2c(%rsi), %edx
movl $0x1f, %esi
jmp 0x50acf
movq %r14, %rdi
movl %ebx, %edx
callq 0x511a2
cmpl %ebx, %eax
je 0x50add
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x50add
movl $0x20, %esi
movl %eax, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x3fa9e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x50d13
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq %rdi, %r14
movzwl 0x60(%rsi), %r12d
testb $0x8, 0x63(%rsi)
movq (%rdi), %rdi
jne 0x50d2e
movl %r12d, %esi
xorl %edx, %edx
jmp 0x50d38
movzwl 0x5e(%r15), %esi
movl %r12d, %edx
subl %esi, %edx
callq 0x50dad
movq %rax, %rbx
testq %rax, %rax
je 0x50cff
testl %r12d, %r12d
je 0x50d8d
movl %r12d, %r12d
xorl %r13d, %r13d
movq 0x40(%r15), %rax
movq (%rax,%r13,8), %rsi
leaq 0x29a01(%rip), %rax     # 0x7a760
cmpq %rax, %rsi
je 0x50d6e
movq %r14, %rdi
callq 0x50e39
jmp 0x50d70
xorl %eax, %eax
movq %rax, 0x20(%rbx,%r13,8)
movq 0x38(%r15), %rax
movb (%rax,%r13), %al
movq 0x18(%rbx), %rcx
movb %al, (%rcx,%r13)
incq %r13
cmpq %r13, %r12
jne 0x50d50
cmpl $0x0, 0x4c(%r14)
je 0x50d01
decl (%rbx)
jne 0x50cff
movq %rbx, %rdi
callq 0xa620
jmp 0x50cff
// File: /workspace/github_c_makefile_star2_O1/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 0x52350
movq %rdi, %r12
movq 0x8(%rsi), %r13
leaq -0x30(%rbp), %rsi
movq %r13, %rdi
callq 0x1bb15
testl %eax, %eax
je 0x52308
cmpl $0x2, %eax
setne %cl
testl %r15d, %r15d
sete %dl
orb %cl, %dl
jne 0x5237d
testl %r15d, %r15d
je 0x52328
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
cmpl $0x2, %eax
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmovneq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rcx
movq %r14, %rdi
movl $0x18, %esi
movl %ebx, %edx
movl $0xfffffff3, %r8d       # imm = 0xFFFFFFF3
callq 0x5444a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsi), %eax
movl %eax, %edx
negl %edx
testl %r15d, %r15d
cmovel %eax, %edx
movq %r14, %rdi
movl $0x17, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3fa9e
leaq 0x2c72f(%rip), %rsi     # 0x7eab3
movq %r13, %rdi
movl $0x2, %edx
callq 0xa560
testl %eax, %eax
je 0x523b0
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 0x523d2
leaq 0x2c6ff(%rip), %rsi     # 0x7eab6
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 0x14804
// File: /workspace/github_c_makefile_star2_O1/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 0x52903
movq (%r14), %rdi
movq 0x80(%r14), %rsi
leaq 0x4(,%rbx,8), %rdx
callq 0x2a8c1
movq %rax, 0x80(%r14)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x52916
movl $0xffffffff, (%rax,%rbx,4) # imm = 0xFFFFFFFF
notl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ExprCachePop
SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse){
  int i;
  struct yColCache *p;
  assert( pParse->iCacheLevel>=1 );
  pParse->iCacheLevel--;
#ifdef SQLITE_DEBUG
  if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
    printf("POP  to %d\n", pParse->iCacheLevel);
  }
#endif
  for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
    if( p->iReg && p->iLevel>pParse->iCacheLevel ){
      cacheEntryClear(pParse, p);
      p->iReg = 0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
decl 0x74(%rdi)
xorl %eax, %eax
movl 0x94(%rdi,%rax), %ecx
testl %ecx, %ecx
je 0x529d7
movl 0x90(%rdi,%rax), %edx
cmpl 0x74(%rdi), %edx
jle 0x529d7
cmpb $0x0, 0x8e(%rdi,%rax)
je 0x529cc
movzbl 0x1f(%rdi), %edx
cmpq $0x7, %rdx
ja 0x529c4
leal 0x1(%rdx), %esi
movb %sil, 0x1f(%rdi)
movl %ecx, 0x24(%rdi,%rdx,4)
movb $0x0, 0x8e(%rdi,%rax)
movl $0x0, 0x94(%rdi,%rax)
addq $0x14, %rax
cmpl $0xc8, %eax
jne 0x5298e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3WalkSelect
SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){
  int rc;
  if( p==0 || (pWalker->xSelectCallback==0 && pWalker->xSelectCallback2==0) ){
    return WRC_Continue;
  }
  rc = WRC_Continue;
  pWalker->walkerDepth++;
  while( p ){
    if( pWalker->xSelectCallback ){
       rc = pWalker->xSelectCallback(pWalker, p);
       if( rc ) break;
    }
    if( sqlite3WalkSelectExpr(pWalker, p)
     || sqlite3WalkSelectFrom(pWalker, p)
    ){
      pWalker->walkerDepth--;
      return WRC_Abort;
    }
    if( pWalker->xSelectCallback2 ){
      pWalker->xSelectCallback2(pWalker, p);
    }
    p = p->pPrior;
  }
  pWalker->walkerDepth--;
  return rc & WRC_Abort;
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x54995
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x5486f
cmpq $0x0, 0x10(%rbx)
je 0x5498d
incl 0x20(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x5488b
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
testl %eax, %eax
jne 0x5497d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x54996
testl %eax, %eax
jne 0x54985
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x547bc
testl %eax, %eax
jne 0x54985
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x54996
testl %eax, %eax
jne 0x54985
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x547bc
testl %eax, %eax
jne 0x54985
movq 0x48(%r14), %rsi
movq %rbx, %rdi
callq 0x54996
testl %eax, %eax
jne 0x54985
movq 0x60(%r14), %rsi
movq %rbx, %rdi
callq 0x547bc
testl %eax, %eax
jne 0x54985
movq 0x68(%r14), %rsi
movq %rbx, %rdi
callq 0x547bc
testl %eax, %eax
jne 0x54985
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x5495d
movl (%r15), %r12d
testl %r12d, %r12d
jle 0x5495d
addq $0x30, %r15
incl %r12d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x54841
testl %eax, %eax
jne 0x54985
testb $0x4, 0x15(%r15)
je 0x54950
movq 0x38(%r15), %rsi
movq %rbx, %rdi
callq 0x54996
testl %eax, %eax
jne 0x54985
addq $0x70, %r15
decl %r12d
cmpl $0x1, %r12d
jg 0x5492a
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x5496e
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x54872
xorl %eax, %eax
decl 0x20(%rbx)
andl $0x2, %eax
jmp 0x5498d
decl 0x20(%rbx)
movl $0x2, %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: sqlite3ExprCanBeNull
SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
  u8 op;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER:
    case TK_STRING:
    case TK_FLOAT:
    case TK_BLOB:
      return 0;
    case TK_COLUMN:
      assert( p->pTab!=0 );
      return ExprHasProperty(p, EP_CanBeNull) ||
             (p->iColumn>=0 && p->pTab->aCol[p->iColumn].notNull==0);
    default:
      return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movzbl %al, %ecx
leal -0x9b(%rcx), %edx
cmpl $0x2, %edx
jae 0x55af0
movq 0x10(%rdi), %rdi
jmp 0x55ada
cmpl $0x9d, %ecx
jne 0x55afb
movb 0x36(%rdi), %al
movzbl %al, %ecx
xorl %eax, %eax
leal -0x84(%rcx), %edx
cmpl $0x3, %edx
jb 0x55b4c
cmpl $0x61, %ecx
je 0x55b4c
movl $0x1, %eax
cmpl $0x98, %ecx
jne 0x55b4c
testb $0x10, 0x6(%rdi)
jne 0x55b4c
movswq 0x30(%rdi), %rcx
movl $0x0, %eax
testq %rcx, %rcx
js 0x55b4c
movq 0x40(%rdi), %rax
movq 0x8(%rax), %rdx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
xorl %eax, %eax
cmpb $0x0, 0x28(%rdx,%rcx)
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3CodeVerifySchema
SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  sqlite3 *db = pToplevel->db;

  assert( iDb>=0 && iDb<db->nDb );
  assert( db->aDb[iDb].pBt!=0 || iDb==1 );
  assert( iDb<SQLITE_MAX_ATTACHED+2 );
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  if( DbMaskTest(pToplevel->cookieMask, iDb)==0 ){
    DbMaskSet(pToplevel->cookieMask, iDb);
    pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
    if( !OMIT_TEMPDB && iDb==1 ){
      sqlite3OpenTempDatabase(pToplevel);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x1c0(%rdi), %rdi
testq %rdi, %rdi
cmoveq %rax, %rdi
movl %esi, %ecx
movl 0x16c(%rdi), %eax
movl $0x1, %edx
shll %cl, %edx
btl %esi, %eax
jb 0x55ba9
movq (%rdi), %rsi
orl %edx, %eax
movl %eax, 0x16c(%rdi)
movq 0x20(%rsi), %rax
movslq %ecx, %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq 0x18(%rax,%rsi), %rax
movl (%rax), %eax
movl %eax, 0x170(%rdi,%rdx,4)
cmpl $0x1, %ecx
jne 0x55ba9
popq %rbp
jmp 0x1e457
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: exprAlwaysTrue
static int exprAlwaysTrue(Expr *p){
  int v = 0;
  if( ExprHasProperty(p, EP_FromJoin) ) return 0;
  if( !sqlite3ExprIsInteger(p, &v) ) return 0;
  return v!=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x0, -0xc(%rbp)
xorl %ebx, %ebx
testb $0x1, 0x4(%rdi)
jne 0x56052
leaq -0xc(%rbp), %rsi
callq 0x55469
testl %eax, %eax
je 0x56052
xorl %ebx, %ebx
cmpl $0x0, -0xc(%rbp)
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ResolveSelfReference
SQLITE_PRIVATE void sqlite3ResolveSelfReference(
  Parse *pParse,      /* Parsing context */
  Table *pTab,        /* The table being referenced */
  int type,           /* NC_IsCheck or NC_PartIdx or NC_IdxExpr */
  Expr *pExpr,        /* Expression to resolve.  May be NULL. */
  ExprList *pList     /* Expression list to resolve.  May be NUL. */
){
  SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
  NameContext sNC;                /* Name context for pParse->pNewTable */

  assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr );
  memset(&sNC, 0, sizeof(sNC));
  memset(&sSrc, 0, sizeof(sSrc));
  sSrc.nSrc = 1;
  sSrc.a[0].zName = pTab->zName;
  sSrc.a[0].pTab = pTab;
  sSrc.a[0].iCursor = -1;
  sNC.pParse = pParse;
  sNC.pSrcList = &sSrc;
  sNC.ncFlags = type;
  if( sqlite3ResolveExprNames(&sNC, pExpr) ) return;
  if( pList ) sqlite3ResolveExprListNames(&sNC, pList);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xb8, %rsp
movq %r8, %rbx
xorl %r8d, %r8d
leaq -0x40(%rbp), %rax
movq %r8, 0x30(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq -0xc0(%rbp), %r9
movaps %xmm0, (%r9)
movaps %xmm0, 0x10(%r9)
movaps %xmm0, 0x20(%r9)
movaps %xmm0, 0x30(%r9)
movaps %xmm0, 0x40(%r9)
movaps %xmm0, 0x50(%r9)
movaps %xmm0, 0x60(%r9)
movq %r8, 0x70(%r9)
movl $0x1, (%r9)
movq (%rsi), %r8
movq %r8, 0x18(%r9)
movq %rsi, 0x28(%r9)
movl $0xffffffff, 0x4c(%r9)  # imm = 0xFFFFFFFF
movq %rdi, (%rax)
movq %r9, 0x8(%rax)
movw %dx, 0x30(%rax)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x56cd9
testq %rbx, %rbx
je 0x5640c
testl %eax, %eax
jne 0x5640c
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x56dcb
addq $0xb8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3TableAffinity
SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
  int i;
  char *zColAff = pTab->zColAff;
  if( zColAff==0 ){
    sqlite3 *db = sqlite3VdbeDb(v);
    zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
    if( !zColAff ){
      db->mallocFailed = 1;
      return;
    }

    for(i=0; i<pTab->nCol; i++){
      zColAff[i] = pTab->aCol[i].affinity;
    }
    do{
      zColAff[i--] = 0;
    }while( i>=0 && zColAff[i]==SQLITE_AFF_BLOB );
    pTab->zColAff = zColAff;
  }
  i = sqlite3Strlen30(zColAff);
  if( i ){
    if( iReg ){
      sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
    }else{
      sqlite3VdbeChangeP4(v, -1, zColAff, i);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rdi, %rbx
movq 0x28(%rsi), %r14
testq %r14, %r14
jne 0x565f1
movq %rsi, %r12
movq (%rbx), %r13
movswq 0x3e(%rsi), %rdi
incq %rdi
callq 0xbf9b
movq %rax, %r14
testq %rax, %rax
je 0x565c8
cmpw $0x0, 0x3e(%r12)
jle 0x565cf
movl $0x29, %ecx
xorl %eax, %eax
movq 0x8(%r12), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%r14,%rax)
incq %rax
movswq 0x3e(%r12), %rdx
addq $0x30, %rcx
cmpq %rdx, %rax
jl 0x565a8
jmp 0x565d1
movb $0x1, 0x51(%r13)
jmp 0x565ec
xorl %eax, %eax
movb $0x0, (%r14,%rax)
testq %rax, %rax
jle 0x565e7
cmpb $0x41, -0x1(%r14,%rax)
leaq -0x1(%rax), %rax
je 0x565d1
movq %r14, 0x28(%r12)
testq %r14, %r14
je 0x56624
movq %r14, %rdi
callq 0xa190
movq %rax, %r12
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
je 0x56624
testl %r15d, %r15d
je 0x56633
movq %rbx, %rdi
movl $0x31, %esi
movl %r15d, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x3fa9e
movl %eax, %esi
jmp 0x56638
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rdx
movl %r12d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14ab9