LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: termCanDriveIndex
static int termCanDriveIndex(
  WhereTerm *pTerm,              /* WHERE clause term to check */
  struct SrcList_item *pSrc,     /* Table we are trying to access */
  Bitmask notReady               /* Tables in outer loops of the join */
){
  char aff;
  if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
  if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) return 0;
  if( (pTerm->prereqRight & notReady)!=0 ) return 0;
  if( pTerm->u.leftColumn<0 ) return 0;
  aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
  if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
  testcase( pTerm->pExpr->op==TK_IS );
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xc(%rdi), %eax
cmpl 0x44(%rsi), %eax
jne 0x5bc14
testb $-0x7e, 0x1a(%rdi)
je 0x5bc14
testq %rdx, 0x28(%rdi)
je 0x5bc18
xorl %eax, %eax
popq %rbp
retq
movslq 0x10(%rdi), %rax
testq %rax, %rax
js 0x5bc14
movq 0x20(%rsi), %rcx
movq 0x8(%rcx), %rcx
imulq $0x30, %rax, %rax
movsbl 0x29(%rcx,%rax), %esi
movq (%rdi), %rdi
popq %rbp
jmp 0x4e35a
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: whereUsablePartialIndex
static int whereUsablePartialIndex(int iTab, WhereClause *pWC, Expr *pWhere){
  int i;
  WhereTerm *pTerm;
  while( pWhere->op==TK_AND ){
    if( !whereUsablePartialIndex(iTab,pWC,pWhere->pLeft) ) return 0;
    pWhere = pWhere->pRight;
  }
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr = pTerm->pExpr;
    if( sqlite3ExprImpliesExpr(pExpr, pWhere, iTab) 
     && (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %r14d
cmpb $0x48, (%rbx)
jne 0x5bcd0
movq 0x10(%rbx), %rdx
movl %r14d, %edi
movq %r15, %rsi
callq 0x5bc9b
testl %eax, %eax
je 0x5bd16
movq 0x18(%rbx), %rbx
jmp 0x5bcb2
movq 0x20(%r15), %r13
movl 0x14(%r15), %r15d
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
subl $0x1, %r15d
jb 0x5bd16
movq (%r13), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x5c462
testl %eax, %eax
je 0x5bd10
testb $0x1, 0x4(%r12)
je 0x5bd1a
movswl 0x34(%r12), %eax
cmpl %r14d, %eax
je 0x5bd1a
addq $0x38, %r13
jmp 0x5bce1
xorl %eax, %eax
jmp 0x5bd1d
pushq $0x1
popq %rax
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: translateColumnToCopy
static void translateColumnToCopy(
  Vdbe *v,            /* The VDBE containing code to translate */
  int iStart,         /* Translate from this opcode to the end */
  int iTabCur,        /* OP_Column/OP_Rowid references to this table */
  int iRegister,      /* The first column is in this register */
  int bIncrRowid      /* If non-zero, transform OP_rowid to OP_AddImm(1) */
){
  VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
  int iEnd = sqlite3VdbeCurrentAddr(v);
  for(; iStart<iEnd; iStart++, pOp++){
    if( pOp->p1!=iTabCur ) continue;
    if( pOp->opcode==OP_Column ){
      pOp->opcode = OP_Copy;
      pOp->p1 = pOp->p2 + iRegister;
      pOp->p2 = pOp->p3;
      pOp->p3 = 0;
    }else if( pOp->opcode==OP_Rowid ){
      if( bIncrRowid ){
        /* Increment the value stored in the P2 operand of the OP_Rowid. */
        pOp->opcode = OP_AddImm;
        pOp->p1 = pOp->p2;
        pOp->p2 = 1;
      }else{
        pOp->opcode = OP_Null;
        pOp->p1 = 0;
        pOp->p3 = 0;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0x386ca
movl 0x3c(%r13), %ecx
addq $0xc, %rax
cmpl %ecx, %r12d
jge 0x5cc8b
cmpl %r15d, -0x8(%rax)
jne 0x5cc82
movzbl -0xc(%rax), %edx
cmpl $0x69, %edx
je 0x5cc60
cmpl $0x30, %edx
jne 0x5cc82
movb $0x1f, -0xc(%rax)
movl -0x4(%rax), %edx
addl %r14d, %edx
movl %edx, -0x8(%rax)
movl (%rax), %edx
movl %edx, -0x4(%rax)
jmp 0x5cc7f
testl %ebx, %ebx
je 0x5cc77
movb $0x26, -0xc(%rax)
movl -0x4(%rax), %edx
movl %edx, -0x8(%rax)
movl $0x1, -0x4(%rax)
jmp 0x5cc82
movb $0x1a, -0xc(%rax)
andl $0x0, -0x8(%rax)
andl $0x0, (%rax)
incl %r12d
addq $0x18, %rax
jmp 0x5cc33
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: explainIndexColumnName
static const char *explainIndexColumnName(Index *pIdx, int i){
  i = pIdx->aiColumn[i];
  if( i==XN_EXPR ) return "<expr>";
  if( i==XN_ROWID ) return "rowid";
  return pIdx->pTable->aCol[i].zName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0xfffe, %eax           # imm = 0xFFFE
je 0x5ccc0
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x5ccc9
leaq 0x10072(%rip), %rax     # 0x6cd30
jmp 0x5ccdd
leaq 0x11eb0(%rip), %rax     # 0x6eb77
jmp 0x5ccdd
movswq %ax, %rax
movq 0x18(%rdi), %rcx
movq 0x8(%rcx), %rcx
imulq $0x30, %rax, %rax
movq (%rcx,%rax), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: explainAppendTerm
static void explainAppendTerm(
  StrAccum *pStr,             /* The text expression being built */
  int iTerm,                  /* Index of this term.  First is zero */
  const char *zColumn,        /* Name of the column */
  const char *zOp             /* Name of the operator */
){
  if( iTerm ) sqlite3StrAccumAppend(pStr, " AND ", 5);
  sqlite3StrAccumAppendAll(pStr, zColumn);
  sqlite3StrAccumAppend(pStr, zOp, 1);
  sqlite3StrAccumAppend(pStr, "?", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
testl %esi, %esi
je 0x5cd08
leaq 0x11e67(%rip), %rsi     # 0x6eb64
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x19b35
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19c16
pushq $0x1
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x19b35
leaq 0x11e41(%rip), %rsi     # 0x6eb6d
movq %rbx, %rdi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x19b35
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: disableTerm
static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
  int nLoop = 0;
  while( pTerm
      && (pTerm->wtFlags & TERM_CODED)==0
      && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
      && (pLevel->notReady & pTerm->prereqAll)==0
  ){
    if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
      pTerm->wtFlags |= TERM_LIKECOND;
    }else{
      pTerm->wtFlags |= TERM_CODED;
    }
    if( pTerm->iParent<0 ) break;
    pTerm = &pTerm->pWC->a[pTerm->iParent];
    pTerm->nChild--;
    if( pTerm->nChild!=0 ) break;
    nLoop++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x4, %ecx
testq %rsi, %rsi
je 0x5cf4f
movzwl 0x1c(%rsi), %edx
testb $0x4, %dl
jne 0x5cf4f
cmpl $0x0, (%rdi)
je 0x5cf08
movq (%rsi), %r8
testb $0x1, 0x4(%r8)
je 0x5cf4f
movq 0x30(%rsi), %r8
testq %r8, 0x50(%rdi)
jne 0x5cf4f
btl $0xa, %edx
movl $0x200, %r8d            # imm = 0x200
cmovael %ecx, %r8d
subl $0x1, %eax
cmovbl %ecx, %r8d
orl %edx, %r8d
movw %r8w, 0x1c(%rsi)
movslq 0x8(%rsi), %rdx
testq %rdx, %rdx
js 0x5cf4f
movq 0x20(%rsi), %rsi
movq 0x20(%rsi), %r8
imulq $0x38, %rdx, %rdx
leaq (%r8,%rdx), %rsi
decb 0x1e(%r8,%rdx)
je 0x5ceeb
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: whereLikeOptimizationStringFixup
static void whereLikeOptimizationStringFixup(
  Vdbe *v,                /* prepared statement under construction */
  WhereLevel *pLevel,     /* The loop that contains the LIKE operator */
  WhereTerm *pTerm        /* The upper or lower bound just coded */
){
  if( pTerm->wtFlags & TERM_LIKEOPT ){
    VdbeOp *pOp;
    assert( pLevel->iLikeRepCntr>0 );
    pOp = sqlite3VdbeGetOp(v, -1);
    assert( pOp!=0 );
    assert( pOp->opcode==OP_String8 
            || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
    pOp->p3 = pLevel->iLikeRepCntr;
    pOp->p5 = 1;
  }
}

// Assembly:
testb $0x1, 0x1d(%rdx)
je 0x5cf78
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $-0x1
popq %rsi
callq 0x386ca
movl 0x24(%rbx), %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x3(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: codeApplyAffinity
static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
  Vdbe *v = pParse->pVdbe;
  if( zAff==0 ){
    assert( pParse->db->mallocFailed );
    return;
  }
  assert( v!=0 );

  /* Adjust base and n to skip over SQLITE_AFF_BLOB entries at the beginning
  ** and end of the affinity string.
  */
  while( n>0 && zAff[0]==SQLITE_AFF_BLOB ){
    n--;
    base++;
    zAff++;
  }
  while( n>1 && zAff[n-1]==SQLITE_AFF_BLOB ){
    n--;
  }

  /* Code the OP_Affinity opcode if there is anything left to do. */
  if( n>0 ){
    sqlite3VdbeAddOp2(v, OP_Affinity, base, n);
    sqlite3VdbeChangeP4(v, -1, zAff, n);
    sqlite3ExprCacheAffinityChange(pParse, base, n);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x5d0ac
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %r12
movl %edx, %eax
sarl $0x1f, %eax
andl %edx, %eax
testl %edx, %edx
jle 0x5d051
cmpb $0x41, (%r15)
jne 0x5d04f
decl %edx
incl %ebx
incq %r15
jmp 0x5d03c
movl %edx, %eax
movl %eax, %eax
movq %rax, %r13
cmpl $0x2, %r13d
jl 0x5d06a
leaq -0x1(%r13), %rax
cmpb $0x41, -0x1(%r15,%r13)
je 0x5d053
jmp 0x5d070
cmpq $0x1, %r13
jne 0x5d0ac
pushq $0x31
popq %rsi
movq %r12, %rdi
movl %ebx, %edx
movl %r13d, %ecx
callq 0x4a1ab
pushq $-0x1
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r13d, %ecx
callq 0x1385d
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ba18
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: sqlite3IndexAffinityStr
SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
  if( !pIdx->zColAff ){
    /* The first time a column affinity string for a particular index is
    ** required, it is allocated and populated here. It is then stored as
    ** a member of the Index structure for subsequent use.
    **
    ** The column affinity string will eventually be deleted by
    ** sqliteDeleteIndex() when the Index structure itself is cleaned
    ** up.
    */
    int n;
    Table *pTab = pIdx->pTable;
    pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
    if( !pIdx->zColAff ){
      db->mallocFailed = 1;
      return 0;
    }
    for(n=0; n<pIdx->nColumn; n++){
      i16 x = pIdx->aiColumn[n];
      if( x>=0 ){
        pIdx->zColAff[n] = pTab->aCol[x].affinity;
      }else if( x==XN_ROWID ){
        pIdx->zColAff[n] = SQLITE_AFF_INTEGER;
      }else{
        char aff;
        assert( x==XN_EXPR );
        assert( pIdx->aColExpr!=0 );
        aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
        if( aff==0 ) aff = SQLITE_AFF_BLOB;
        pIdx->zColAff[n] = aff;
      }
    }
    pIdx->zColAff[n] = 0;
  }
 
  return pIdx->zColAff;
}

// Assembly:
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x5d0c5
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
movzwl 0x60(%rsi), %edi
incq %rdi
callq 0xc13f
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x5d166
xorl %r14d, %r14d
pushq $0x41
popq %r13
xorl %r12d, %r12d
movzwl 0x60(%rbx), %eax
cmpq %rax, %r12
jae 0x5d157
movq 0x8(%rbx), %rax
movswq (%rax,%r12,2), %rax
testq %rax, %rax
js 0x5d130
movq 0x8(%r15), %rcx
imulq $0x30, %rax, %rax
movb 0x29(%rcx,%rax), %cl
movq 0x20(%rbx), %rax
movb %cl, (%rax,%r12)
incq %r12
addq $0x20, %r14
jmp 0x5d0fc
cmpw $-0x1, %ax
je 0x5d153
movq 0x50(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14), %rdi
callq 0x4dd22
movl %r13d, %ecx
testb %al, %al
je 0x5d11f
movzbl %al, %ecx
jmp 0x5d11f
movb $0x44, %cl
jmp 0x5d11f
movq 0x20(%rbx), %rax
movb $0x0, (%rax,%r12)
movq 0x20(%rbx), %rax
jmp 0x5d16d
movb $0x1, 0x51(%r14)
xorl %eax, %eax
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: sqlite3MaterializeView
SQLITE_PRIVATE void sqlite3MaterializeView(
  Parse *pParse,       /* Parsing context */
  Table *pView,        /* View definition */
  Expr *pWhere,        /* Optional WHERE clause to be added */
  int iCur             /* Cursor number for ephemeral table */
){
  SelectDest dest;
  Select *pSel;
  SrcList *pFrom;
  sqlite3 *db = pParse->db;
  int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
  pWhere = sqlite3ExprDup(db, pWhere, 0);
  pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
  if( pFrom ){
    assert( pFrom->nSrc==1 );
    pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
    pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
    assert( pFrom->a[0].pOn==0 );
    assert( pFrom->a[0].pUsing==0 );
  }
  pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 
                          SF_IncludeHidden, 0, 0);
  sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
  sqlite3Select(pParse, pSel, &dest);
  sqlite3SelectDelete(db, pSel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x68(%rsi), %rsi
movq %rbx, %rdi
callq 0x136fb
movl %eax, %r12d
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4d4c2
movq %rax, -0x38(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x432ee
movq %rax, %r13
testq %rax, %rax
je 0x5db99
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x11f6d
movq %rax, 0x18(%r13)
movq 0x20(%rbx), %rax
movslq %r12d, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %rbx, %rdi
callq 0x11f6d
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andq $0x0, (%rsp)
movl $0x8000, 0x8(%rsp)      # imm = 0x8000
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq -0x38(%rbp), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x42fec
movq %rax, %r15
leaq -0x50(%rbp), %rdx
movw $0xc, (%rdx)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%rdx)
andq $0x0, 0x8(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fba5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x368d0
addq $0x48, %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: sqlite3VtabMakeWritable
SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  int i, n;
  Table **apVtabLock;

  assert( IsVirtual(pTab) );
  for(i=0; i<pToplevel->nVtabLock; i++){
    if( pTab==pToplevel->apVtabLock[i] ) return;
  }
  n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
  apVtabLock = sqlite3_realloc64(pToplevel->apVtabLock, n);
  if( apVtabLock ){
    pToplevel->apVtabLock = apVtabLock;
    pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
  }else{
    pToplevel->db->mallocFailed = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x1c0(%rdi), %r14
testq %r14, %r14
cmoveq %rdi, %r14
movl 0x1f0(%r14), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x5dda7
movq 0x268(%r14), %rsi
leaq 0x1(%rcx), %rdi
cmpq %rbx, (%rsi,%rcx,8)
movq %rdi, %rcx
jne 0x5dd8c
jmp 0x5dde7
leal 0x8(,%rax,8), %eax
movq 0x268(%r14), %rdi
movslq %eax, %rsi
callq 0xa7e0
testq %rax, %rax
je 0x5dde0
movq %rax, 0x268(%r14)
movslq 0x1f0(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x1f0(%r14)
movq %rbx, (%rax,%rcx,8)
jmp 0x5dde7
movq (%r14), %rax
movb $0x1, 0x51(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3AutoincrementEnd
SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
  AutoincInfo *p;
  Vdbe *v = pParse->pVdbe;
  sqlite3 *db = pParse->db;

  assert( v );
  for(p = pParse->pAinc; p; p = p->pNext){
    Db *pDb = &db->aDb[p->iDb];
    int addr1;
    int iRec;
    int memId = p->regCtr;

    iRec = sqlite3GetTempReg(pParse);
    assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
    sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
    addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1); VdbeCoverage(v);
    sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);
    sqlite3VdbeJumpHere(v, addr1);
    sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
    sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);
    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
    sqlite3VdbeAddOp0(v, OP_Close);
    sqlite3ReleaseTempReg(pParse, iRec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rdi), %r14
movq %rdi, -0x38(%rbp)
leaq 0x1b8(%rdi), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x5e189
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movslq 0x10(%r13), %r12
movl 0x14(%r13), %r15d
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4c550
movl %eax, -0x2c(%rbp)
movl 0x10(%r13), %edx
shlq $0x5, %r12
movq -0x48(%rbp), %rax
movq 0x18(%rax,%r12), %rax
movq 0x68(%rax), %rcx
movq %rbx, %rdi
xorl %esi, %esi
pushq $0x38
popq %r8
callq 0x4a0e1
leal 0x1(%r15), %r12d
movq %r14, %rdi
pushq $0x4d
popq %rsi
movl %r12d, %edx
callq 0x4b9b3
movl %eax, %ebx
movq %r14, %rdi
pushq $0x54
popq %rsi
xorl %edx, %edx
movl %r12d, %ecx
callq 0x4a1ab
movq %r14, %rdi
movl %ebx, %esi
callq 0x4a022
decl %r15d
movq %r14, %rdi
pushq $0x32
popq %rsi
movl %r15d, %edx
pushq $0x2
popq %rcx
movl -0x2c(%rbp), %ebx
movl %ebx, %r8d
callq 0x385b6
movq %r14, %rdi
pushq $0x5f
popq %rsi
xorl %edx, %edx
movl %ebx, %ecx
movl %r12d, %r8d
callq 0x385b6
movq %r14, %rdi
pushq $0x8
popq %rsi
callq 0x13770
movq %r14, %rdi
pushq $0x3e
popq %rsi
callq 0x4a011
movq -0x38(%rbp), %rdi
movl %ebx, %esi
callq 0x4c573
jmp 0x5e0b6
addq $0x28, %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: targetSrcList
static SrcList *targetSrcList(
  Parse *pParse,       /* The parsing context */
  TriggerStep *pStep   /* The trigger containing the target token */
){
  sqlite3 *db = pParse->db;
  int iDb;             /* Index of the database to use */
  SrcList *pSrc;       /* SrcList to be returned */

  pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
  if( pSrc ){
    assert( pSrc->nSrc>0 );
    pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);
    iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema);
    if( iDb==0 || iDb>=2 ){
      assert( iDb<db->nDb );
      pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
    }
  }
  return pSrc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq (%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x432ee
movq %rax, %r14
testq %rax, %rax
je 0x5f717
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x11f6d
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x58(%rcx,%r14)
movq 0x8(%r15), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x136fb
testl %eax, %eax
setne %cl
cmpl $0x2, %eax
setl %dl
testb %dl, %cl
jne 0x5f717
movq %r14, %r15
addq $0x8, %r15
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq %rbx, %rdi
callq 0x11f6d
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x68(%rcx,%r15)
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: returnSingleText
static void returnSingleText(
  Vdbe *v,                /* Prepared statement under construction */
  const char *zLabel,     /* Name of the result column */
  const char *zValue      /* Value to be returned */
){
  if( zValue ){
    sqlite3VdbeLoadString(v, 1, (const char*)zValue);
    setOneColumnName(v, zLabel);
    sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
  }
}

// Assembly:
testq %rdx, %rdx
je 0x610ae
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %r15
movl %r15d, %esi
callq 0x4a187
movq %rbx, %rdi
movq %r14, %rsi
callq 0x610af
pushq $0x22
popq %rsi
movq %rbx, %rdi
movl %r15d, %edx
movl %r15d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4a1ab
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeSetSpillSize
SQLITE_PRIVATE int sqlite3BtreeSetSpillSize(Btree *p, int mxPage){
  BtShared *pBt = p->pBt;
  int res;
  assert( sqlite3_mutex_held(p->db->mutex) );
  sqlite3BtreeEnter(p);
  res = sqlite3PagerSetSpillsize(pBt->pPager, mxPage);
  sqlite3BtreeLeave(p);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %r15
callq 0xf01a
movq (%r15), %rax
movq 0x110(%rax), %rdi
testl %r14d, %r14d
je 0x6122f
jns 0x61229
movslq %r14d, %rax
shlq $0xa, %rax
negq %rax
movslq 0x24(%rdi), %rcx
movslq 0x28(%rdi), %rsi
addq %rcx, %rsi
cqto
idivq %rsi
movq %rax, %r14
movl %r14d, 0x20(%rdi)
jmp 0x61233
movl 0x20(%rdi), %r14d
callq 0x1ce3b
movl %eax, %r15d
cmpl %r14d, %eax
cmovlel %r14d, %r15d
movq %rbx, %rdi
callq 0x1034d
movl %r15d, %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: setAllColumnNames
static void setAllColumnNames(
  Vdbe *v,               /* The query under construction */
  int N,                 /* Number of columns */
  const char **azCol     /* Names of columns */
){
  int i;
  sqlite3VdbeSetNumCols(v, N);
  for(i=0; i<N; i++){
    sqlite3VdbeSetColName(v, i, COLNAME_NAME, azCol[i], SQLITE_STATIC);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
callq 0x39091
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
cmpq %r12, %r14
je 0x613e6
movq (%rbx,%r12,8), %rcx
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x3910e
incq %r12
jmp 0x613c8
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: sqlite3VdbeMultiLoad
SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){
  va_list ap;
  int i;
  char c;
  va_start(ap, zTypes);
  for(i=0; (c = zTypes[i])!=0; i++){
    if( c=='s' ){
      const char *z = va_arg(ap, const char*);
      int addr = sqlite3VdbeAddOp2(p, z==0 ? OP_Null : OP_String8, 0, iDest++);
      if( z ) sqlite3VdbeChangeP4(p, addr, z, 0);
    }else{
      assert( c=='i' );
      sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest++);
    }
  }
  va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq -0xf0(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x6144f
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %rdx, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, -0x40(%rbp)
pushq $0x17
popq %r12
movzbl (%rbx), %eax
cmpl $0x73, %eax
je 0x61495
testl %eax, %eax
je 0x61511
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x614ea
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x614f6
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x614ad
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x614b9
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %r13
pushq $0x1a
popq %rsi
testq %r13, %r13
je 0x614c7
pushq $0x61
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x4a1ab
testq %r13, %r13
je 0x61506
movq %r15, %rdi
movl %eax, %esi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x1385d
jmp 0x61506
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %edx
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %ecx
callq 0x4a1ab
incl %r14d
incq %rbx
jmp 0x6146d
addq $0xc8, %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: likeFunc
static void likeFunc(
  sqlite3_context *context, 
  int argc, 
  sqlite3_value **argv
){
  const unsigned char *zA, *zB;
  u32 escape = 0;
  int nPat;
  sqlite3 *db = sqlite3_context_db_handle(context);

#ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
  if( sqlite3_value_type(argv[0])==SQLITE_BLOB
   || sqlite3_value_type(argv[1])==SQLITE_BLOB
  ){
#ifdef SQLITE_TEST
    sqlite3_like_count++;
#endif
    sqlite3_result_int(context, 0);
    return;
  }
#endif
  zB = sqlite3_value_text(argv[0]);
  zA = sqlite3_value_text(argv[1]);

  /* Limit the length of the LIKE or GLOB pattern to avoid problems
  ** of deep recursion and N*N behavior in patternCompare().
  */
  nPat = sqlite3_value_bytes(argv[0]);
  testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
  testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
  if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
    sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
    return;
  }
  assert( zB==sqlite3_value_text(argv[0]) );  /* Encoding did not change */

  if( argc==3 ){
    /* The escape character string must consist of a single UTF-8 character.
    ** Otherwise, return an error.
    */
    const unsigned char *zEsc = sqlite3_value_text(argv[2]);
    if( zEsc==0 ) return;
    if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
      sqlite3_result_error(context, 
          "ESCAPE expression must be a single character", -1);
      return;
    }
    escape = sqlite3Utf8Read(&zEsc);
  }
  if( zA && zB ){
    struct compareInfo *pInfo = sqlite3_user_data(context);
#ifdef SQLITE_TEST
    sqlite3_like_count++;
#endif
    
    sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rax), %r14
movq (%rdx), %rdi
callq 0xa830
movq %rax, -0x30(%rbp)
movq 0x8(%r12), %rdi
callq 0xa830
movq %rax, %r15
movq (%r12), %rdi
callq 0xa600
cmpl 0x88(%r14), %eax
jle 0x61669
leaq 0xde35(%rip), %rsi      # 0x6f485
pushq $-0x1
popq %rdx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa200
xorl %ecx, %ecx
cmpl $0x3, %r13d
jne 0x6169f
movq 0x10(%r12), %rdi
callq 0xa830
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x616f0
pushq $-0x1
popq %rsi
movq %rax, %rdi
callq 0x3914d
cmpl $0x1, %eax
jne 0x616de
leaq -0x38(%rbp), %rdi
callq 0x38bce
movl %eax, %ecx
testq %r15, %r15
setne %al
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0x616f0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdx
movq %r15, %rsi
callq 0x1422d
movq %rbx, %rdi
movl %eax, %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa280
leaq 0xddc1(%rip), %rsi      # 0x6f4a6
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0xa200
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: triggerStepAllocate
static TriggerStep *triggerStepAllocate(
  sqlite3 *db,                /* Database connection */
  u8 op,                      /* Trigger opcode */
  Token *pName                /* The target name */
){
  TriggerStep *pTriggerStep;

  pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
  if( pTriggerStep ){
    char *z = (char*)&pTriggerStep[1];
    memcpy(z, pName->z, pName->n);
    sqlite3Dequote(z);
    pTriggerStep->zTarget = z;
    pTriggerStep->op = op;
  }
  return pTriggerStep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movl 0x8(%rdx), %esi
addq $0x49, %rsi
callq 0x12153
movq %rax, %r14
testq %rax, %rax
je 0x61790
movq %r14, %r12
addq $0x48, %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %r12, %rdi
callq 0xa3b0
movq %r12, %rdi
callq 0x4e83e
movq %r12, 0x18(%r14)
movb %bl, (%r14)
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: resolveAttachExpr
static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
{
  int rc = SQLITE_OK;
  if( pExpr ){
    if( pExpr->op!=TK_ID ){
      rc = sqlite3ResolveExprNames(pName, pExpr);
    }else{
      pExpr->op = TK_STRING;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x622b9
cmpb $0x1b, (%rsi)
jne 0x622bd
movb $0x61, (%rsi)
xorl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x4f020
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: printfFunc
static void printfFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  PrintfArguments x;
  StrAccum str;
  const char *zFormat;
  int n;
  sqlite3 *db = sqlite3_context_db_handle(context);

  if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
    x.nArg = argc-1;
    x.nUsed = 0;
    x.apArg = argv+1;
    sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
    sqlite3XPrintf(&str, SQLITE_PRINTF_SQLFUNC, zFormat, &x);
    n = str.nChar;
    sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
                        SQLITE_DYNAMIC);
  }
}

// Assembly:
testl %esi, %esi
jle 0x63b8e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rax), %r12
movq (%rdx), %rdi
callq 0xa830
testq %rax, %rax
je 0x63b82
decl %r15d
leaq -0x30(%rbp), %rcx
movl %r15d, (%rcx)
andl $0x0, 0x4(%rcx)
addq $0x8, %r14
movq %r14, 0x8(%rcx)
movl 0x68(%r12), %edx
xorps %xmm0, %xmm0
leaq -0x58(%rbp), %r14
movups %xmm0, 0x8(%r14)
movq %r12, (%r14)
andq $0x0, 0x18(%r14)
movl %edx, 0x20(%r14)
andw $0x0, 0x24(%r14)
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3765e
movl 0x18(%r14), %r15d
movq %r14, %rdi
callq 0xd700
leaq -0x57888(%rip), %rcx    # 0xc2ec
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0xa160
addq $0x40, %rsp
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: groupConcatStep
static void groupConcatStep(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  const char *zVal;
  StrAccum *pAccum;
  const char *zSep;
  int nVal, nSep;
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));

  if( pAccum ){
    sqlite3 *db = sqlite3_context_db_handle(context);
    int firstTerm = pAccum->mxAlloc==0;
    pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
    if( !firstTerm ){
      if( argc==2 ){
        zSep = (char*)sqlite3_value_text(argv[1]);
        nSep = sqlite3_value_bytes(argv[1]);
      }else{
        zSep = ",";
        nSep = 1;
      }
      if( nSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep);
    }
    zVal = (char*)sqlite3_value_text(argv[0]);
    nVal = sqlite3_value_bytes(argv[0]);
    if( zVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdx), %rax
movl 0x8(%rax), %eax
movl $0xaaaaaaaa, %ecx       # imm = 0xAAAAAAAA
btl %eax, %ecx
jb 0x64a7a
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r12
pushq $0x28
popq %rsi
callq 0xa390
testq %rax, %rax
je 0x64a7a
movq %rax, %r14
movq (%r12), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x20(%r14)
movl 0x68(%rax), %eax
movl %eax, 0x20(%r14)
je 0x64a4d
cmpl $0x2, %r15d
jne 0x64a38
movq 0x8(%rbx), %rdi
callq 0xa830
movq %rax, %r15
movq 0x8(%rbx), %rdi
callq 0xa600
testl %eax, %eax
je 0x64a4d
movl %eax, %edx
jmp 0x64a42
pushq $0x1
popq %rdx
leaq 0x98e5(%rip), %r15      # 0x6e327
movq %r14, %rdi
movq %r15, %rsi
callq 0x19b35
movq (%rbx), %rdi
callq 0xa830
movq %rax, %r15
movq (%rbx), %rdi
callq 0xa600
testq %r15, %r15
je 0x64a7a
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x19b35
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: pcache1Init
static int pcache1Init(void *NotUsed){
  UNUSED_PARAMETER(NotUsed);
  assert( pcache1.isInit==0 );
  memset(&pcache1, 0, sizeof(pcache1));


  /*
  ** The pcache1.separateCache variable is true if each PCache has its own
  ** private PGroup (mode-1).  pcache1.separateCache is false if the single
  ** PGroup in pcache1.grp is used for all page caches (mode-2).
  **
  **   *  Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
  **
  **   *  Use a unified cache in single-threaded applications that have
  **      configured a start-time buffer for use as page-cache memory using
  **      sqlite3_config(SQLITE_CONFIG_PAGECACHE, pBuf, sz, N) with non-NULL 
  **      pBuf argument.
  **
  **   *  Otherwise use separate caches (mode-1)
  */
#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)
  pcache1.separateCache = 0;
#elif SQLITE_THREADSAFE
  pcache1.separateCache = sqlite3GlobalConfig.pPage==0
                          || sqlite3GlobalConfig.bCoreMutex>0;
#else
  pcache1.separateCache = sqlite3GlobalConfig.pPage==0;
#endif

#if SQLITE_THREADSAFE
  if( sqlite3GlobalConfig.bCoreMutex ){
    pcache1.grp.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU);
    pcache1.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PMEM);
  }
#endif
  if( pcache1.separateCache
   && sqlite3GlobalConfig.nPage!=0
   && sqlite3GlobalConfig.pPage==0
  ){
    pcache1.nInitPage = sqlite3GlobalConfig.nPage;
  }else{
    pcache1.nInitPage = 0;
  }
  pcache1.grp.mxPinned = 10;
  pcache1.isInit = 1;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x1ed8c(%rip), %rdi     # 0x85540
xorl %ebx, %ebx
movl $0x90, %edx
xorl %esi, %esi
callq 0xa270
movq 0x1cda7(%rip), %rax     # 0x83570
testq %rax, %rax
sete %dl
movl 0x1cc4f(%rip), %esi     # 0x83424
testl %esi, %esi
setg %cl
orb %dl, %cl
movzbl %cl, %edx
movl %edx, 0x1edaf(%rip)     # 0x85594
testl %esi, %esi
je 0x66818
pushq $0x6
popq %rdi
callq 0xa1b0
movq %rax, 0x1ed48(%rip)     # 0x85540
pushq $0x7
popq %rdi
callq 0xa1b0
movq %rax, 0x1edb1(%rip)     # 0x855b8
movq 0x1cd62(%rip), %rax     # 0x83570
cmpl $0x0, 0x1ed7f(%rip)     # 0x85594
setne %cl
movl 0x1cd5e(%rip), %edx     # 0x8357c
testq %rax, %rax
movl $0x0, %eax
cmovel %edx, %eax
testl %edx, %edx
cmovel %edx, %eax
testb %cl, %cl
cmovel %ebx, %eax
movl %eax, 0x1ed5f(%rip)     # 0x85598
movl $0xa, 0x1ed0d(%rip)     # 0x85550
movl $0x1, 0x1ed43(%rip)     # 0x85590
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: pcache1EnforceMaxPage
static void pcache1EnforceMaxPage(PCache1 *pCache){
  PGroup *pGroup = pCache->pGroup;
  PgHdr1 *p;
  assert( sqlite3_mutex_held(pGroup->mutex) );
  while( pGroup->nCurrentPage>pGroup->nMaxPage
      && (p=pGroup->lru.pLruPrev)->isAnchor==0
  ){
    assert( p->pCache->pGroup==pGroup );
    assert( p->isPinned==0 );
    pcache1PinPage(p);
    pcache1RemoveFromHash(p, 1);
  }
  if( pCache->nPage==0 && pCache->pBulk ){
    sqlite3_free(pCache->pBulk);
    pCache->pBulk = pCache->pFree = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r12
pushq $0x1
popq %r14
movl 0x14(%r12), %eax
cmpl 0x8(%r12), %eax
jbe 0x66c08
movq 0x48(%r12), %r15
cmpb $0x0, 0x16(%r15)
jne 0x66c08
movq %r15, %rdi
callq 0x66c2c
movq %r15, %rdi
movl %r14d, %esi
callq 0x66c57
jmp 0x66bdb
cmpl $0x0, 0x2c(%rbx)
jne 0x66c23
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x66c23
callq 0xa828
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
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: pcache1FreePage
static void pcache1FreePage(PgHdr1 *p){
  PCache1 *pCache;
  assert( p!=0 );
  pCache = p->pCache;
  assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
  if( p->isBulkLocal ){
    p->pNext = pCache->pFree;
    pCache->pFree = p;
  }else{
    pcache1Free(p->page.pBuf);
#ifdef SQLITE_PCACHE_SEPARATE_HEADER
    sqlite3_free(p);
#endif
  }
  if( pCache->bPurgeable ){
    pCache->pGroup->nCurrentPage--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rbx
cmpb $0x0, 0x15(%rdi)
je 0x66cae
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rdi)
movq %rdi, 0x40(%rbx)
jmp 0x66cb6
movq (%rdi), %rdi
callq 0x1efa2
cmpl $0x0, 0x14(%rbx)
je 0x66cc2
movq (%rbx), %rax
decl 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VtabDisconnect
SQLITE_PRIVATE void sqlite3VtabDisconnect(sqlite3 *db, Table *p){
  VTable **ppVTab;

  assert( IsVirtual(p) );
  assert( sqlite3BtreeHoldsAllMutexes(db) );
  assert( sqlite3_mutex_held(db->mutex) );

  for(ppVTab=&p->pVTable; *ppVTab; ppVTab=&(*ppVTab)->pNext){
    if( (*ppVTab)->db==db  ){
      VTable *pVTab = *ppVTab;
      *ppVTab = pVTab->pNext;
      sqlite3VtabUnlock(pVTab);
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addq $0x58, %rsi
movq (%rsi), %rax
testq %rax, %rax
je 0x6708f
movq %rsi, %rcx
leaq 0x28(%rax), %rsi
cmpq %rdi, (%rax)
jne 0x6706b
movq 0x28(%rax), %rdx
movq %rdx, (%rcx)
movq %rax, %rdi
popq %rbp
jmp 0x24d3d
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: binCollFunc
static int binCollFunc(
  void *padFlag,
  int nKey1, const void *pKey1,
  int nKey2, const void *pKey2
){
  int rc, n;
  n = nKey1<nKey2 ? nKey1 : nKey2;
  /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
  ** strings byte by byte using the memcmp() function from the standard C
  ** library. */
  rc = memcmp(pKey1, pKey2, n);
  if( rc==0 ){
    if( padFlag
     && allSpaces(((char*)pKey1)+n, nKey1-n)
     && allSpaces(((char*)pKey2)+n, nKey2-n)
    ){
      /* EVIDENCE-OF: R-31624-24737 RTRIM is like BINARY except that extra
      ** spaces at the end of either string do not change the result. In other
      ** words, strings will compare equal to one another as long as they
      ** differ only in the number of spaces at the end.
      */
    }else{
      rc = nKey1 - nKey2;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, -0x38(%rbp)
movl %esi, %ebx
subl %ecx, %ebx
movl %ecx, %eax
cmovll %esi, %eax
movslq %eax, %r15
movq %rdx, %rdi
movq %r8, -0x30(%rbp)
movq %r8, %rsi
movq %r15, %rdx
callq 0xa2e0
testl %eax, %eax
jne 0x671a5
cmpq $0x0, -0x38(%rbp)
je 0x671a3
addq %r15, %r12
subl %r15d, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x671da
testl %eax, %eax
je 0x671a3
movq -0x30(%rbp), %rdi
addq %r15, %rdi
subl %r15d, %r14d
movl %r14d, %esi
callq 0x671da
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x671a5
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/lseek1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);

	assert(fd >= 0);
	unlink(tmpfile);

	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));

	while (1) {
		lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rbx
movaps 0x7bd(%rip), %xmm0      # 0x3300
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movabsq $0x5858585858582e, %rax # imm = 0x5858585858582E
movq %rax, 0x10(%rdi)
callq 0x21d0
testl %eax, %eax
js 0x2b93
movl %eax, %ebp
movq %rsp, %rdi
callq 0x2080
leaq 0x20(%rsp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x20d0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2bac
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
jmp 0x2b83
leaq 0x6e2(%rip), %rdi       # 0x327c
leaq 0x6e3(%rip), %rsi       # 0x3284
leaq 0x6eb(%rip), %rcx       # 0x3293
pushq $0x10
jmp 0x2bc3
leaq 0x713(%rip), %rdi       # 0x32c6
leaq 0x6ca(%rip), %rsi       # 0x3284
leaq 0x6d2(%rip), %rcx       # 0x3293
pushq $0x13
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/mloar[P]charset/fromucs.c
// Function: charset_from_unicode
int charset_from_unicode(const wchar_t **input, int *inlen,
			 char *output, int outlen,
			 int charset, charset_state *state, int *error)
{
    charset_spec const *spec = charset_find_spec(charset);
    charset_state localstate = CHARSET_INIT_STATE;
    struct charset_emit_param param;
    int locallen;

    if (!input) {
	locallen = 1;
	inlen = &locallen;
    }

    param.output = output;
    param.outlen = outlen;
    param.writtenlen = 0;
    param.stopped = 0;

    if (state)
	localstate = *state;	       /* structure copy */
    if (error)
	*error = FALSE;

    while (*inlen > 0) {
	int lenbefore = param.writtenlen;
	int ret;

	if (input)
	    ret = spec->write(spec, **input, &localstate,
			      charset_emit, &param);
	else
	    ret = spec->write(spec, -1, &localstate, charset_emit, &param);
	if (error && !ret) {
	    /*
	     * We have hit a difficult character, which the user
	     * wants to know about. Leave now.
	     */
	    *error = TRUE;
	    return lenbefore;
	}
	if (param.stopped) {
	    /*
	     * The emit function has _tried_ to output some
	     * characters, but ran up against the end of the
	     * buffer. Leave immediately, and return what happened
	     * _before_ attempting to process this character.
	     */
	    return lenbefore;
	}
	if (state)
	    *state = localstate;       /* structure copy */
	if (input)
	    (*input)++;
	(*inlen)--;
    }
    return param.writtenlen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movl %r8d, %edi
callq 0x6938
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
testq %r14, %r14
jne 0x66ab
leaq 0x34(%rsp), %r15
movl $0x1, (%r15)
movq 0x70(%rsp), %rcx
movq %r13, 0x18(%rsp)
movl %ebp, 0x20(%rsp)
andq $0x0, 0x24(%rsp)
testq %rbx, %rbx
je 0x66cb
movups (%rbx), %xmm0
movaps %xmm0, (%rsp)
testq %rcx, %rcx
je 0x66d3
andl $0x0, (%rcx)
movl (%r15), %eax
movl 0x24(%rsp), %ebp
testl %eax, %eax
jle 0x673e
movq %rcx, %r13
pushq $-0x1
popq %rsi
testq %r14, %r14
je 0x66ef
movq (%r14), %rax
movslq (%rax), %rsi
movq %r12, %rdi
movq %rsp, %rdx
leaq 0x53(%rip), %rcx        # 0x674f
leaq 0x18(%rsp), %r8
callq *0x10(%r12)
movq %r13, %rcx
testq %r13, %r13
je 0x6712
testl %eax, %eax
je 0x6738
cmpl $0x0, 0x28(%rsp)
jne 0x673e
testq %rbx, %rbx
je 0x6725
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
testq %r14, %r14
je 0x672e
addq $0x4, (%r14)
movl (%r15), %eax
decl %eax
movl %eax, (%r15)
jmp 0x66d6
movl $0x1, (%rcx)
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mloar[P]charset/fromucs.c
// Function: charset_emit
static void charset_emit(void *ctx, long int output)
{
    struct charset_emit_param *param = (struct charset_emit_param *)ctx;

    if (param->outlen != 0) {
	if (param->output)
	    *param->output++ = output;
	if (param->outlen > 0)
	    param->outlen--;
	param->writtenlen++;
    } else {
	param->stopped = 1;
    }
}

// Assembly:
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x6778
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x676b
leaq 0x1(%rcx), %rax
movq %rax, (%rdi)
movb %sil, (%rcx)
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x6774
decl %eax
movl %eax, 0x8(%rdi)
incl 0xc(%rdi)
retq
movl $0x1, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/eiselekd[P]MinimalLisp/./lf1.c
// Function: lf_eval
v *
lf_eval(lfctx *lfctx) 
{
    fctx *cctx = (fctx *)lfctx;
    v *r = 0, *f; v *e = POP;
    switch(e->tag) {
    case INT: case STR:
        PUSH(e);
        PUSH(mkInt(0));
        break;
    case SYM:
        if ((r = assq(e, TOSE))) {
            r = cdr(r);
        } else {
            fprintf(stderr, "Undefined symbol \"%s\"\n", str(e));
        }
        PUSH(r);
        PUSH(mkInt(0));
        break;
    case FUNC:
        break;
    case CONS:
        PUSH(cdr(e));
        PUSH(car(e));
        PUSH(mkInt(1));
        break;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x120(%rdi), %rax
testq %rax, %rax
je 0xa85b
movq 0x10(%rax), %r14
movq %r14, 0x120(%rbx)
movq 0x8(%rax), %r15
jmp 0xa861
xorl %r14d, %r14d
xorl %r15d, %r15d
movl (%r15), %eax
andl $0xf, %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xa88a
testl %eax, %eax
je 0xa899
cmpl $0x3, %eax
jne 0xa8c0
movq 0x178(%rbx), %rax
testq %rax, %rax
je 0xa8c5
movq 0x8(%rax), %rsi
jmp 0xa8c7
movq %r15, %rdi
movq %r14, %rsi
callq 0x2362
xorl %edi, %edi
jmp 0xa8bb
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x2362
movq %rax, 0x120(%rbx)
movq 0x8(%r15), %rdi
movq %rax, %rsi
callq 0x2362
pushq $0x1
popq %rdi
xorl %r15d, %r15d
jmp 0xa8e5
xorl %r15d, %r15d
jmp 0xa907
xorl %esi, %esi
movq %r15, %rdi
callq 0x27b2
testq %rax, %rax
je 0xa915
movq 0x10(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2362
xorl %edi, %edi
movq %rax, 0x120(%rbx)
callq 0x2383
movq 0x120(%rbx), %rsi
movq %rax, %rdi
callq 0x2362
movq %rax, 0x120(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x56dc(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq 0x8(%r15), %rdx
leaq 0x181b(%rip), %rsi      # 0xc145
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x20c0
movq 0x120(%rbx), %r14
jmp 0xa8d8