LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3IndexAffinityOk
SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
  char aff = comparisonAffinity(pExpr);
  switch( aff ){
    case SQLITE_AFF_BLOB:
      return 1;
    case SQLITE_AFF_TEXT:
      return idx_affinity==SQLITE_AFF_TEXT;
    default:
      return sqlite3IsNumericAffinity(idx_affinity);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x451a72
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x4680de
testb $0x8, 0x5(%r14)
jne 0x4680d3
testb %al, %al
jne 0x4680e6
jmp 0x4680fa
movq 0x20(%r14), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdi
movsbl %al, %esi
callq 0x451b33
cmpb $0x41, %al
je 0x4680fa
movzbl %al, %eax
cmpl $0x42, %eax
jne 0x4680fe
cmpb $0x42, %bl
sete %al
jmp 0x468104
movb $0x1, %al
jmp 0x468104
cmpb $0x43, %bl
setge %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: whereUsablePartialIndex
static int whereUsablePartialIndex(int iTab, WhereClause *pWC, Expr *pWhere){
  int i;
  WhereTerm *pTerm;
  Parse *pParse = pWC->pWInfo->pParse;
  while( pWhere->op==TK_AND ){
    if( !whereUsablePartialIndex(iTab,pWC,pWhere->pLeft) ) return 0;
    pWhere = pWhere->pRight;
  }
  if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0;
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr = pTerm->pExpr;
    if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
     && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab) 
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq (%rsi), %rax
movq (%rax), %r15
cmpb $0x2c, (%rdx)
jne 0x469bdf
movq 0x10(%rbx), %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x469ba6
testl %eax, %eax
je 0x469c2e
movq 0x18(%rbx), %rbx
cmpb $0x2c, (%rbx)
je 0x469bc4
movq (%r15), %rcx
xorl %eax, %eax
testb $-0x80, 0x32(%rcx)
cmovneq %rax, %r15
movl 0x14(%r14), %ecx
testl %ecx, %ecx
jle 0x469c37
movq 0x20(%r14), %r12
xorl %r13d, %r13d
movq (%r12), %rsi
testb $0x1, 0x4(%rsi)
je 0x469c0d
movswl 0x34(%rsi), %eax
cmpl %ebp, %eax
jne 0x469c22
movq %r15, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x46a69e
testl %eax, %eax
jne 0x469c32
movl 0x14(%r14), %ecx
incl %r13d
addq $0x40, %r12
cmpl %ecx, %r13d
jl 0x469bfb
xorl %eax, %eax
jmp 0x469c37
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprImpliesExpr
SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse *pParse, Expr *pE1, Expr *pE2, int iTab){
  if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){
    return 1;
  }
  if( pE2->op==TK_OR
   && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab)
             || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) )
  ){
    return 1;
  }
  if( pE2->op==TK_NOTNULL && pE1->op!=TK_ISNULL && pE1->op!=TK_IS ){
    Expr *pX = sqlite3ExprSkipCollate(pE1->pLeft);
    testcase( pX!=pE1->pLeft );
    if( sqlite3ExprCompare(pParse, pX, pE2->pLeft, iTab)==0 ) return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x451ec3
movl $0x1, %ebx
testl %eax, %eax
je 0x46a74c
movb (%r15), %al
cmpb $0x2b, %al
jne 0x46a6f7
movq 0x10(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0x46a69e
testl %eax, %eax
jne 0x46a74c
movq 0x18(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0x46a69e
testl %eax, %eax
jne 0x46a74c
movb (%r15), %al
cmpb $0x33, %al
jne 0x46a74a
movzbl (%r12), %eax
cmpl $0x2d, %eax
je 0x46a74a
cmpl $0x32, %eax
je 0x46a74a
movq 0x10(%r12), %rsi
testq %rsi, %rsi
je 0x46a736
movl 0x4(%rsi), %eax
btl $0xc, %eax
jae 0x46a738
btl $0x12, %eax
jb 0x46a729
addq $0x10, %rsi
jmp 0x46a731
movq 0x20(%rsi), %rsi
addq $0x8, %rsi
movq (%rsi), %rsi
jmp 0x46a70f
xorl %esi, %esi
movq 0x10(%r15), %rdx
movq %r14, %rdi
movl %ebp, %ecx
callq 0x451ec3
testl %eax, %eax
je 0x46a74c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: exprIdxCover
static int exprIdxCover(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_COLUMN
   && pExpr->iTable==pWalker->u.pIdxCover->iCur
   && sqlite3ColumnOfIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
  ){
    pWalker->eCode = 1;
    return WRC_Abort;
  }
  return WRC_Continue;
}

// Assembly:
xorl %eax, %eax
cmpb $-0x62, (%rsi)
jne 0x46a7a0
movl 0x2c(%rsi), %edx
movq 0x28(%rdi), %rcx
cmpl 0x8(%rcx), %edx
jne 0x46a7a0
movq (%rcx), %rcx
movzwl 0x60(%rcx), %eax
testq %rax, %rax
je 0x46a797
movzwl 0x30(%rsi), %edx
movq 0x8(%rcx), %rsi
xorl %ecx, %ecx
cmpw %dx, (%rsi,%rcx,2)
je 0x46a790
incq %rcx
cmpq %rcx, %rax
jne 0x46a780
jmp 0x46a797
xorl %eax, %eax
testw %cx, %cx
jns 0x46a7a0
movb $0x1, 0x24(%rdi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: translateColumnToCopy
static void translateColumnToCopy(
  Parse *pParse,      /* Parsing context */
  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) */
){
  Vdbe *v = pParse->pVdbe;
  VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
  int iEnd = sqlite3VdbeCurrentAddr(v);
  if( pParse->db->mallocFailed ) return;
  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:
movq 0x10(%rdi), %r9
movl %esi, %eax
testl %esi, %esi
jns 0x46b0b6
movl 0xb8(%r9), %eax
decl %eax
movq (%r9), %r10
cmpb $0x0, 0x61(%r10)
je 0x46b0c9
leaq 0x139d41(%rip), %rax    # 0x5a4e08
jmp 0x46b0d7
cltq
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x68(%r9), %rax
movl 0xb8(%r9), %r9d
movq (%rdi), %rdi
cmpb $0x0, 0x61(%rdi)
sete %dil
subl %esi, %r9d
setg %sil
andb %dil, %sil
cmpb $0x1, %sil
jne 0x46b158
addq $0xc, %rax
xorl %esi, %esi
cmpl %edx, -0x8(%rax)
jne 0x46b14f
movzbl -0xc(%rax), %edi
cmpl $0x81, %edi
je 0x46b12e
cmpl $0x5a, %edi
jne 0x46b14f
movb $0x4e, -0xc(%rax)
movl -0x4(%rax), %edi
addl %ecx, %edi
movl %edi, -0x8(%rax)
movl (%rax), %edi
movl %edi, -0x4(%rax)
movl $0x0, (%rax)
jmp 0x46b14f
testl %r8d, %r8d
je 0x46b146
movb $0x53, -0xc(%rax)
movl -0x4(%rax), %edi
movl %edi, -0x8(%rax)
movl $0x1, -0x4(%rax)
jmp 0x46b14f
movb $0x49, -0xc(%rax)
movl %esi, -0x8(%rax)
movl %esi, (%rax)
addq $0x18, %rax
decl %r9d
jne 0x46b0ff
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/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 ){
    sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rcx, %rcx
je 0x46be74
movl %edx, %eax
movq %rdi, %rbx
testl %edx, %edx
jle 0x46be28
movl %eax, %r14d
addq %rcx, %r14
leal (%rax,%rsi), %edx
cmpb $0x41, (%rcx)
jne 0x46be28
leal -0x1(%rax), %edi
incl %esi
incq %rcx
cmpl $0x1, %eax
movl %edi, %eax
jg 0x46be10
xorl %eax, %eax
jmp 0x46be2d
movq %rcx, %r14
movl %esi, %edx
movl %eax, %eax
movq %rax, %r15
cmpl $0x2, %r15d
jl 0x46be46
leaq -0x1(%r15), %rax
cmpb $0x41, -0x1(%r14,%r15)
je 0x46be2f
jmp 0x46be4c
cmpq $0x1, %r15
jne 0x46be74
movq %rbx, %rdi
movl $0x5b, %esi
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x43a65f
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %r15d, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x40e765
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: codeDeferredSeek
static void codeDeferredSeek(
  WhereInfo *pWInfo,              /* Where clause context */
  Index *pIdx,                    /* Index scan is using */
  int iCur,                       /* Cursor for IPK b-tree */
  int iIdxCur                     /* Index cursor */
){
  Parse *pParse = pWInfo->pParse; /* Parse context */
  Vdbe *v = pParse->pVdbe;        /* Vdbe to generate code within */

  assert( iIdxCur>0 );
  assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );
  
  sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur);
  if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
   && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask)
  ){
    int i;
    Table *pTab = pIdx->pTable;
    int *ai = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*(pTab->nCol+1));
    if( ai ){
      ai[0] = pTab->nCol;
      for(i=0; i<pIdx->nColumn-1; i++){
        assert( pIdx->aiColumn[i]<pTab->nCol );
        if( pIdx->aiColumn[i]>=0 ) ai[pIdx->aiColumn[i]+1] = i+1;
      }
      sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r12
movq 0x10(%r12), %rbx
movq %rbx, %rdi
movl $0x87, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x43a65f
testb $0x20, 0x40(%r15)
je 0x46bec0
movq 0xa0(%r12), %rax
testq %rax, %rax
cmoveq %r12, %rax
cmpl $0x0, 0x70(%rax)
je 0x46becc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r14), %r15
movq (%r12), %rdi
movswq 0x46(%r15), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x40c786
testq %rax, %rax
je 0x46bec0
movswl 0x46(%r15), %ecx
movl %ecx, (%rax)
movzwl 0x60(%r14), %ecx
cmpq $0x2, %rcx
jb 0x46bf1f
decl %ecx
movq 0x8(%r14), %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
testw %di, %di
js 0x46bf17
leal 0x1(%rsi), %r8d
movl %r8d, 0x4(%rax,%rdi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x46bf05
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rax, %rdx
movl $0xfffffff1, %ecx       # imm = 0xFFFFFFF1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40e765
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: whereIndexExprTrans
static void whereIndexExprTrans(
  Index *pIdx,      /* The Index */
  int iTabCur,      /* Cursor of the table that is being indexed */
  int iIdxCur,      /* Cursor of the index itself */
  WhereInfo *pWInfo /* Transform expressions in this WHERE clause */
){
  int iIdxCol;               /* Column number of the index */
  ExprList *aColExpr;        /* Expressions that are indexed */
  Walker w;
  IdxExprTrans x;
  aColExpr = pIdx->aColExpr;
  if( aColExpr==0 ) return;  /* Not an index on expressions */
  memset(&w, 0, sizeof(w));
  w.xExprCallback = whereIndexExprTransNode;
  w.u.pIdxTrans = &x;
  x.iTabCur = iTabCur;
  x.iIdxCur = iIdxCur;
  for(iIdxCol=0; iIdxCol<aColExpr->nExpr; iIdxCol++){
    if( pIdx->aiColumn[iIdxCol]!=XN_EXPR ) continue;
    assert( aColExpr->a[iIdxCol].pExpr!=0 );
    x.iIdxCol = iIdxCol;
    x.pIdxExpr = aColExpr->a[iIdxCol].pExpr;
    sqlite3WalkExpr(&w, pWInfo->pWhere);
    sqlite3WalkExprList(&w, pWInfo->pOrderBy);
    sqlite3WalkExprList(&w, pWInfo->pResultSet);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x50(%rdi), %r12
testq %r12, %r12
je 0x46bff7
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x12c(%rip), %rax       # 0x46c0a2
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
movl (%r12), %eax
testl %eax, %eax
jle 0x46bff7
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x8(%r12), %r13
xorl %ebp, %ebp
movq %rsp, %r15
movq 0x8(%r14), %rcx
cmpw $-0x2, (%rcx,%rbp,2)
jne 0x46bfe8
movl %ebp, 0x40(%rsp)
movq (%r13), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x46bfcc
movq %r15, %rdi
callq 0x451c38
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x451e70
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x451e70
movl (%r12), %eax
incq %rbp
movslq %eax, %rcx
addq $0x20, %r13
cmpq %rcx, %rbp
jl 0x46bfa3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: whereIndexExprTransNode
static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
  IdxExprTrans *pX = p->u.pIdxTrans;
  if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
    pExpr->op = TK_COLUMN;
    pExpr->iTable = pX->iIdxCur;
    pExpr->iColumn = pX->iIdxCol;
    pExpr->pTab = 0;
    return WRC_Prune;
  }else{
    return WRC_Continue;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rdi), %r15
movq (%r15), %rdx
movl 0x8(%r15), %ecx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x451ec3
testl %eax, %eax
jne 0x46c0e4
movb $-0x62, (%rbx)
movl 0xc(%r15), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r15), %eax
movw %ax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: windowCheckIntValue
static void windowCheckIntValue(Parse *pParse, int reg, int eCond){
  static const char *azErr[] = {
    "frame starting offset must be a non-negative integer",
    "frame ending offset must be a non-negative integer",
    "second argument to nth_value must be a positive integer"
  };
  static int aOp[] = { OP_Ge, OP_Ge, OP_Gt };
  Vdbe *v = sqlite3GetVdbe(pParse);
  int regZero = sqlite3GetTempReg(pParse);
  assert( eCond==0 || eCond==1 || eCond==2 );
  sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero);
  sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2);
  VdbeCoverageIf(v, eCond==0);
  VdbeCoverageIf(v, eCond==1);
  VdbeCoverageIf(v, eCond==2);
  sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg);
  VdbeCoverageNeverNullIf(v, eCond==0);
  VdbeCoverageNeverNullIf(v, eCond==1);
  VdbeCoverageNeverNullIf(v, eCond==2);
  sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort);
  sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC);
  sqlite3ReleaseTempReg(pParse, regZero);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x44dbe5
movq %rax, %r14
movb 0x1f(%rbx), %al
testb %al, %al
je 0x46c39b
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xc4(%rbx,%rax,4), %ebp
jmp 0x46c3a3
movl 0x38(%rbx), %ebp
incl %ebp
movl %ebp, 0x38(%rbx)
movq %r14, %rdi
movl $0x46, %esi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x43a65f
movl 0xb8(%r14), %ecx
addl $0x2, %ecx
movq %r14, %rdi
movl $0xf, %esi
movl %r15d, %edx
xorl %r8d, %r8d
callq 0x43a65f
movl %r12d, %r12d
leaq 0xe3b76(%rip), %rax     # 0x54ff54
movl (%rax,%r12,4), %esi
movl 0xb8(%r14), %ecx
addl $0x2, %ecx
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
callq 0x43a65f
movq %r14, %rdi
movl $0x45, %esi
movl $0x1, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x43a65f
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x46c443
leaq 0xe3b25(%rip), %rax     # 0x54ff48
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
movq 0x68(%r14), %rax
movslq 0xb8(%r14), %rdx
leaq (%rdx,%rdx,2), %rdx
movb $-0x1, -0x17(%rax,%rdx,8)
movq %rcx, -0x8(%rax,%rdx,8)
testl %ebp, %ebp
je 0x46c45e
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x46c45e
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xc4(%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: windowInitAccum
static int windowInitAccum(Parse *pParse, Window *pMWin){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int regArg;
  int nArg = 0;
  Window *pWin;
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *pFunc = pWin->pFunc;
    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
    nArg = MAX(nArg, windowArgCount(pWin));
    if( pFunc->zName==nth_valueName
     || pFunc->zName==first_valueName
    ){
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
    }

    if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){
      assert( pWin->eStart!=TK_UNBOUNDED );
      sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
    }
  }
  regArg = pParse->nMem+1;
  pParse->nMem += nArg;
  return regArg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
callq 0x44dbe5
testq %r14, %r14
je 0x46c55d
movq %rax, %r15
leaq 0xe3a91(%rip), %r13     # 0x54ff22
leaq 0xe3a94(%rip), %rbx     # 0x54ff2c
xorl %ebp, %ebp
movq 0x40(%r14), %r12
movl 0x4c(%r14), %ecx
movq %r15, %rdi
movl $0x49, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43a65f
movq 0x60(%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x46c4c7
movl (%rax), %eax
cmpl %eax, %ebp
jmp 0x46c4ce
testl %ebp, %ebp
movl $0x0, %eax
cmovlel %eax, %ebp
movq 0x38(%r12), %rax
cmpq %r13, %rax
setne %cl
cmpq %rbx, %rax
setne %al
testb %al, %cl
jne 0x46c514
movl 0x58(%r14), %ecx
movq %r15, %rdi
movl $0x46, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43a65f
movl 0x58(%r14), %ecx
incl %ecx
movq %r15, %rdi
movl $0x46, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43a65f
testb $0x10, 0x5(%r12)
je 0x46c54e
movl 0x54(%r14), %edx
testl %edx, %edx
je 0x46c54e
movq %r15, %rdi
movl $0x8b, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43a65f
movl 0x58(%r14), %ecx
incl %ecx
movq %r15, %rdi
movl $0x46, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43a65f
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x46c49a
jmp 0x46c55f
xorl %ebp, %ebp
movq (%rsp), %rdx
movl 0x38(%rdx), %ecx
leal 0x1(%rcx), %eax
addl %ecx, %ebp
movl %ebp, 0x38(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: windowReturnRows
static void windowReturnRows(
  Parse *pParse,
  Window *pMWin,                  /* List of window functions */
  int regCtr,                     /* Register containing number of rows */
  int regGosub,                   /* Register for Gosub addrGosub */
  int addrGosub,                  /* Address of sub-routine for ReturnOneRow */
  int regInvArg,                  /* Array of registers for xInverse args */
  int regInvSize                  /* Register containing size of partition */
){
  int addr;
  Vdbe *v = sqlite3GetVdbe(pParse);
  windowAggFinal(pParse, pMWin, 0);
  addr = sqlite3VdbeAddOp3(v, OP_IfPos, regCtr, sqlite3VdbeCurrentAddr(v)+2 ,1);
  VdbeCoverage(v);
  sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
  windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
  if( regInvArg ){
    windowAggStep(pParse, pMWin, pMWin->iEphCsr, 1, regInvArg, regInvSize);
  }
  sqlite3VdbeAddOp2(v, OP_Next, pMWin->iEphCsr, addr);
  VdbeCoverage(v);
  sqlite3VdbeJumpHere(v, addr+1);   /* The OP_Goto */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, 0x4(%rsp)
movl %ecx, %r13d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
callq 0x44dbe5
movq %rax, %rbx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x46ca47
movl 0xb8(%rbx), %ecx
addl $0x2, %ecx
movq %rbx, %rdi
movl $0x2f, %esi
movl %r15d, %edx
movl $0x1, %r8d
callq 0x43a65f
movl %eax, %r15d
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43a65f
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %edx
movl 0x4(%rsp), %ecx
callq 0x46cc1f
testl %ebp, %ebp
je 0x46d09b
movl 0x40(%rsp), %r9d
movl 0x48(%r14), %edx
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x46c57d
movl 0x48(%r14), %edx
movq %rbx, %rdi
movl $0x5, %esi
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x43a65f
movl 0xb8(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x46d0ca
leaq 0x137d40(%rip), %rcx    # 0x5a4e08
jmp 0x46d0e7
leal 0x1(%r15), %ecx
leal -0x1(%rax), %edx
cmpl $-0x1, %r15d
cmovgel %ecx, %edx
movslq %edx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x68(%rbx), %rcx
movl %eax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: havingToWhereExprCb
static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
  if( pExpr->op!=TK_AND ){
    Select *pS = pWalker->u.pSelect;
    if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
      sqlite3 *db = pWalker->pParse->db;
      Expr *pNew = sqlite3ExprAlloc(db, TK_INTEGER, &sqlite3IntTokens[1], 0);
      if( pNew ){
        Expr *pWhere = pS->pWhere;
        SWAP(Expr, *pNew, *pExpr);
        pNew = sqlite3ExprAnd(db, pWhere, pNew);
        pS->pWhere = pNew;
        pWalker->eCode = 1;
      }
    }
    return WRC_Prune;
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
xorl %ebp, %ebp
cmpb $0x2c, (%rsi)
je 0x46d7cd
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rdi), %r12
movq 0x38(%r12), %rcx
movq %rsp, %r15
movb $0x1, 0x24(%r15)
leaq 0xa0(%rip), %rdx        # 0x46d7dc
movq %rdx, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq %rcx, 0x28(%r15)
movq %rax, (%r15)
movq %r15, %rdi
callq 0x451c38
cmpb $0x0, 0x24(%r15)
movl $0x1, %ebp
je 0x46d7cd
movq (%rbx), %rax
movq (%rax), %r15
leaq 0x130c30(%rip), %rdx    # 0x59e3a0
movq %r15, %rdi
movl $0x8f, %esi
xorl %ecx, %ecx
callq 0x4443be
testq %rax, %rax
je 0x46d7cd
movq 0x30(%r12), %rdx
movq %rsp, %r8
movl $0xa, %ecx
movq %r8, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %r14, %rdi
movq %r8, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x458727
movq %rax, 0x30(%r12)
movb $0x1, 0x24(%rbx)
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/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 ){
      const char *zDb;
      assert( iDb<db->nDb );
      zDb = db->aDb[iDb].zDbSName;
      pSrc->a[pSrc->nSrc-1].zDatabase =  sqlite3DbStrDup(db, zDb);
    }
  }
  return pSrc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x44453c
movq %rax, %r14
testq %rax, %rax
je 0x46ff5d
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x40c587
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x58(%rcx,%r14)
movq 0x8(%r15), %rax
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x46ff20
movq 0x20(%rbx), %rdx
addq $0x18, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
leaq 0x20(%rdx), %rsi
cmpq %rcx, (%rdx)
movq %rsi, %rdx
jne 0x46ff10
jmp 0x46ff25
movl $0xfff0bdc0, %eax       # imm = 0xFFF0BDC0
testl %eax, %eax
setne %cl
cmpl $0x2, %eax
setl %dl
testb %dl, %cl
jne 0x46ff5d
movq %r14, %r15
addq $0x8, %r15
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq %rbx, %rdi
callq 0x40c587
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x68(%rcx,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3BtreeSecureDelete
SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){
  int b;
  if( p==0 ) return 0;
  sqlite3BtreeEnter(p);
  assert( BTS_OVERWRITE==BTS_SECURE_DELETE*2 );
  assert( BTS_FAST_SECURE==(BTS_OVERWRITE|BTS_SECURE_DELETE) );
  if( newFlag>=0 ){
    p->pBt->btsFlags &= ~BTS_FAST_SECURE;
    p->pBt->btsFlags |= BTS_SECURE_DELETE*newFlag;
  }
  b = (p->pBt->btsFlags & BTS_FAST_SECURE)/BTS_SECURE_DELETE;
  sqlite3BtreeLeave(p);
  return b;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x473b95
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
je 0x473b5a
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x473b5a
movq %rbx, %rdi
callq 0x420275
movq 0x8(%rbx), %rax
movzwl 0x26(%rax), %r14d
testl %ebp, %ebp
js 0x473b78
andl $-0xd, %r14d
shll $0x2, %ebp
orl %r14d, %ebp
movw %bp, 0x26(%rax)
movl %ebp, %r14d
shrl $0x2, %r14d
andl $0x3, %r14d
cmpb $0x0, 0x11(%rbx)
je 0x473b98
decl 0x14(%rbx)
jne 0x473b98
movq %rbx, %rdi
callq 0x4202fb
jmp 0x473b98
xorl %r14d, %r14d
movzwl %r14w, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: detachFunc
static void detachFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  const char *zName = (const char *)sqlite3_value_text(argv[0]);
  sqlite3 *db = sqlite3_context_db_handle(context);
  int i;
  Db *pDb = 0;
  char zErr[128];

  UNUSED_PARAMETER(NotUsed);

  if( zName==0 ) zName = "";
  for(i=0; i<db->nDb; i++){
    pDb = &db->aDb[i];
    if( pDb->pBt==0 ) continue;
    if( sqlite3StrICmp(pDb->zDbSName, zName)==0 ) break;
  }

  if( i>=db->nDb ){
    sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
    goto detach_error;
  }
  if( i<2 ){
    sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
    goto detach_error;
  }
  if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
    sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
    goto detach_error;
  }

  sqlite3BtreeClose(pDb->pBt);
  pDb->pBt = 0;
  pDb->pSchema = 0;
  sqlite3CollapseDatabaseArray(db);
  return;

detach_error:
  sqlite3_result_error(context, zErr, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movl $0x1, %esi
callq 0x40af5d
movq (%rbx), %rcx
testq %rax, %rax
leaq 0xfd176(%rip), %r14     # 0x57234d
cmovneq %rax, %r14
movq 0x28(%rcx), %rax
movslq 0x28(%rax), %r15
testq %r15, %r15
jle 0x475219
movq %rax, 0x8(%rsp)
movq 0x20(%rax), %rbp
xorl %r12d, %r12d
movq 0x8(%rbp), %r13
testq %r13, %r13
je 0x47520d
movq (%rbp), %rdi
movq %r14, %rsi
callq 0x4079b2
testl %eax, %eax
je 0x47526c
incq %r12
addq $0x20, %rbp
cmpq %r12, %r15
jne 0x4751f4
leaq 0xdec35(%rip), %rdx     # 0x553e55
leaq 0x10(%rsp), %r12
movl $0x80, %edi
movq %r12, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x407596
movl $0x1, 0x24(%rbx)
movq (%rbx), %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x40b1de
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x2, %r12
jae 0x47527b
leaq 0xdebf1(%rip), %rdx     # 0x553e6a
jmp 0x475220
leaq 0xdec02(%rip), %rdx     # 0x553e84
cmpb $0x0, 0x10(%r13)
jne 0x475220
cmpl $0x0, 0x18(%r13)
jne 0x475220
movq %r13, %rdi
callq 0x4244b9
xorl %eax, %eax
movq %rax, 0x8(%rbp)
movq %rax, 0x18(%rbp)
movq 0x8(%rsp), %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43b274
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameTestSchema
static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){
  sqlite3NestedParse(pParse, 
      "SELECT 1 "
      "FROM \"%w\".%s "
      "WHERE name NOT LIKE 'sqlite_%%'"
      " AND sql NOT LIKE 'create virtual%%'"
      " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ",
      zDb, MASTER_NAME, 
      zDb, bTemp
  );

  if( bTemp==0 ){
    sqlite3NestedParse(pParse, 
        "SELECT 1 "
        "FROM temp.%s "
        "WHERE name NOT LIKE 'sqlite_%%'"
        " AND sql NOT LIKE 'create virtual%%'"
        " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ",
        MASTER_NAME, zDb 
    );
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xddf67(%rip), %rsi     # 0x554297
leaq 0xdaf5d(%rip), %rcx     # 0x551294
movq %rbx, %rdx
movq %rbx, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x454481
testl %ebp, %ebp
je 0x476350
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xddfd0(%rip), %rsi     # 0x554327
leaq 0xdaf36(%rip), %rdx     # 0x551294
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x454481
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3InsertBuiltinFuncs
SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(
  FuncDef *aDef,      /* List of global functions to be inserted */
  int nDef            /* Length of the apDef[] list */
){
  int i;
  for(i=0; i<nDef; i++){
    FuncDef *pOther;
    const char *zName = aDef[i].zName;
    int nName = sqlite3Strlen30(zName);
    int h = (zName[0] + nName) % SQLITE_FUNC_HASH_SZ;
    assert( zName[0]>='a' && zName[0]<='z' );
    pOther = functionSearch(h, zName);
    if( pOther ){
      assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
      aDef[i].pNext = pOther->pNext;
      pOther->pNext = &aDef[i];
    }else{
      aDef[i].pNext = 0;
      aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h];
      sqlite3BuiltinFunctions.a[h] = &aDef[i];
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x4782fe
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r12d
leaq 0x12c813(%rip), %r13    # 0x5a4a70
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x478275
movq %r14, %rdi
callq 0x401100
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x478277
xorl %eax, %eax
movsbl (%r14), %ecx
addl %eax, %ecx
movslq %ecx, %rax
imulq $-0x4de9bd37, %rax, %r15 # imm = 0xB21642C9
shrq $0x20, %r15
addl %eax, %r15d
movl %r15d, %ecx
shrl $0x1f, %ecx
sarl $0x4, %r15d
addl %ecx, %r15d
leal (%r15,%r15,2), %ecx
shll $0x3, %ecx
subl %ecx, %r15d
addl %eax, %r15d
movl %r15d, %edi
movq %r14, %rsi
callq 0x47bc8a
testq %rax, %rax
je 0x4782c3
addq $0x10, %rax
movl $0x10, %ecx
jmp 0x4782de
movq $0x0, 0x10(%rbx)
movslq %r15d, %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movl $0x40, %ecx
movq (%rax), %rdx
movq %rdx, (%rbx,%rcx)
movq %rbx, (%rax)
addq $0x48, %rbx
decq %r12
jne 0x47825d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameParseSql
static int renameParseSql(
  Parse *p,                       /* Memory to use for Parse object */
  const char *zDb,                /* Name of schema SQL belongs to */
  int bTable,                     /* 1 -> RENAME TABLE, 0 -> RENAME COLUMN */
  sqlite3 *db,                    /* Database handle */
  const char *zSql,               /* SQL to parse */
  int bTemp                       /* True if SQL is from temp schema */
){
  int rc;
  char *zErr = 0;

  db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);

  /* Parse the SQL statement passed as the first argument. If no error
  ** occurs and the parse does not result in a new table, index or
  ** trigger object, the database must be corrupt. */
  memset(p, 0, sizeof(Parse));
  p->eParseMode = (bTable ? PARSE_MODE_RENAME_TABLE : PARSE_MODE_RENAME_COLUMN);
  p->db = db;
  p->nQueryLoop = 1;
  rc = sqlite3RunParser(p, zSql, &zErr);
  assert( p->zErrMsg==0 );
  assert( rc!=SQLITE_OK || zErr==0 );
  assert( (0!=p->pNewTable) + (0!=p->pNewIndex) + (0!=p->pNewTrigger)<2 );
  p->zErrMsg = zErr;
  if( db->mallocFailed ) rc = SQLITE_NOMEM;
  if( rc==SQLITE_OK 
   && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0 
  ){
    rc = SQLITE_CORRUPT_BKPT;
  }

#ifdef SQLITE_DEBUG
  /* Ensure that all mappings in the Parse.pRename list really do map to
  ** a part of the input string.  */
  if( rc==SQLITE_OK ){
    int nSql = sqlite3Strlen30(zSql);
    RenameToken *pToken;
    for(pToken=p->pRename; pToken; pToken=pToken->pNext){
      assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
    }
  }
#endif

  db->init.iDb = 0;
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movb $0x1, %al
testl %r9d, %r9d
jne 0x4792ce
movq %rbx, %rdi
callq 0x413be9
movb %al, 0xb4(%rbx)
leaq 0x8(%r14), %rdi
movl $0x190, %edx            # imm = 0x190
xorl %esi, %esi
callq 0x4010b8
testl %ebp, %ebp
sete %al
xorb $0x3, %al
movb %al, 0x10c(%r14)
movq %rbx, (%r14)
movl $0x1, 0xb4(%r14)
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x41102a
movq (%r12), %rcx
movq %rcx, 0x8(%r14)
cmpb $0x0, 0x61(%rbx)
movl $0x7, %ebp
cmovel %eax, %ebp
testl %ebp, %ebp
jne 0x479341
cmpq $0x0, 0x138(%r14)
jne 0x47933f
cmpq $0x0, 0x140(%r14)
je 0x479357
xorl %ebp, %ebp
movb $0x0, 0xb4(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x148(%r14)
movl $0x0, %ebp
jne 0x479341
leaq 0xd75c2(%rip), %rsi     # 0x55092f
leaq 0xd76de(%rip), %rdx     # 0x550a52
leaq 0xd73eb(%rip), %r8      # 0x550766
movl $0xb, %ebp
movl $0xb, %edi
movl $0x18ebb, %ecx          # imm = 0x18EBB
xorl %eax, %eax
callq 0x40765d
jmp 0x479341
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameColumnElistNames
static void renameColumnElistNames(
  Parse *pParse, 
  RenameCtx *pCtx, 
  ExprList *pEList, 
  const char *zOld
){
  if( pEList ){
    int i;
    for(i=0; i<pEList->nExpr; i++){
      char *zName = pEList->a[i].zName;
      if( 0==sqlite3_stricmp(zName, zOld) ){
        renameTokenFind(pParse, pCtx, (void*)zName);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0x479767
movq %rdx, %r14
movslq (%rdx), %rbp
testq %rbp, %rbp
jle 0x479767
movq %rcx, %rbx
addq $0x8, %r14
xorl %r15d, %r15d
movq %rcx, %rax
negq %rax
movl $0x0, %r12d
sbbl %r12d, %r12d
addq $0x190, 0x8(%rsp)       # imm = 0x190
movq %r15, %rax
shlq $0x5, %rax
movq 0x8(%r14,%rax), %r13
movl %r12d, %eax
testq %r13, %r13
je 0x479716
testq %rbx, %rbx
je 0x47975f
movq %r13, %rdi
movq %rbx, %rsi
callq 0x4079b2
testl %eax, %eax
jne 0x47975f
movq 0x8(%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x47975f
movq 0x8(%rsp), %rcx
cmpq %r13, (%rax)
je 0x479746
movq %rax, %rcx
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x47975f
cmpq %r13, (%rax)
jne 0x479731
addq $0x18, %rcx
movq 0x18(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, (%rdx)
incl 0x8(%rdx)
incq %r15
cmpq %rbp, %r15
jne 0x4796f2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameParseCleanup
static void renameParseCleanup(Parse *pParse){
  sqlite3 *db = pParse->db;
  if( pParse->pVdbe ){
    sqlite3VdbeFinalize(pParse->pVdbe);
  }
  sqlite3DeleteTable(db, pParse->pNewTable);
  if( pParse->pNewIndex ) sqlite3FreeIndex(db, pParse->pNewIndex);
  sqlite3DeleteTrigger(db, pParse->pNewTrigger);
  sqlite3DbFree(db, pParse->zErrMsg);
  renameTokenFree(db, pParse->pRename);
  sqlite3ParserReset(pParse);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x479bde
callq 0x40abba
movq 0x138(%rbx), %rsi
movq %r14, %rdi
callq 0x404acb
movq 0x140(%rbx), %rsi
testq %rsi, %rsi
je 0x479c01
movq %r14, %rdi
callq 0x438185
movq 0x148(%rbx), %rsi
movq %r14, %rdi
callq 0x404a62
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x479c21
movq %r14, %rdi
callq 0x415f0a
movq 0x190(%rbx), %rsi
testq %rsi, %rsi
je 0x479c41
movq 0x18(%rsi), %r15
movq %r14, %rdi
callq 0x415f0a
movq %r15, %rsi
testq %r15, %r15
jne 0x479c2d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40ec43
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameTableExprCb
static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
  RenameCtx *p = pWalker->u.pRename;
  if( pExpr->op==TK_COLUMN && p->pTab==pExpr->pTab ){
    renameTokenFind(pWalker->pParse, p, (void*)&pExpr->pTab);
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x62, (%rsi)
jne 0x479cab
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rcx
cmpq 0x40(%rsi), %rcx
jne 0x479cab
movq (%rdi), %rdx
movq 0x190(%rdx), %rcx
testq %rcx, %rcx
je 0x479cab
addq $0x40, %rsi
cmpq %rsi, (%rcx)
je 0x479c90
movq %rcx, %rdx
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0x479cab
cmpq %rsi, (%rcx)
jne 0x479c79
addq $0x18, %rdx
jmp 0x479c97
addq $0x190, %rdx            # imm = 0x190
movq 0x18(%rcx), %rsi
movq %rsi, (%rdx)
movq (%rax), %rdx
movq %rdx, 0x18(%rcx)
movq %rcx, (%rax)
incl 0x8(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameTableSelectCb
static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
  int i;
  RenameCtx *p = pWalker->u.pRename;
  SrcList *pSrc = pSelect->pSrc;
  for(i=0; i<pSrc->nSrc; i++){
    struct SrcList_item *pItem = &pSrc->a[i];
    if( pItem->pTab==p->pTab ){
      renameTokenFind(pWalker->pParse, p, pItem->zName);
    }
  }

  return WRC_Continue;
}

// Assembly:
movq 0x28(%rsi), %rax
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x479d28
movq 0x28(%rdi), %rdx
addq $0x8, %rax
xorl %esi, %esi
imulq $0x70, %rsi, %r10
movq 0x20(%rax,%r10), %r8
cmpq 0x10(%rdx), %r8
jne 0x479d20
movq (%rdi), %r9
movq 0x190(%r9), %r8
testq %r8, %r8
je 0x479d20
addq %rax, %r10
movq 0x10(%r10), %r10
cmpq %r10, (%r8)
je 0x479d05
movq %r8, %r9
movq 0x18(%r8), %r8
testq %r8, %r8
je 0x479d20
cmpq %r10, (%r8)
jne 0x479cee
addq $0x18, %r9
jmp 0x479d0c
addq $0x190, %r9             # imm = 0x190
movq 0x18(%r8), %r10
movq %r10, (%r9)
movq (%rdx), %r9
movq %r9, 0x18(%r8)
movq %r8, (%rdx)
incl 0x8(%rdx)
incq %rsi
cmpq %rcx, %rsi
jne 0x479cc4
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: percent_rankStepFunc
static void percent_rankStepFunc(
  sqlite3_context *pCtx, 
  int nArg,
  sqlite3_value **apArg
){
  struct CallCount *p;
  UNUSED_PARAMETER(nArg); assert( nArg==1 );

  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nTotal = sqlite3_value_int64(apArg[0]);
    }
    p->nStep++;
    if( p->nValue==0 ){
      p->nValue = p->nStep;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x479ec7
movl $0x18, %esi
callq 0x40c613
movq %rax, %rbx
jmp 0x479ecb
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x479ef7
cmpq $0x0, 0x10(%rbx)
jne 0x479ee3
movq (%r14), %rdi
callq 0x40aeec
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
incq %rax
movq %rax, 0x8(%rbx)
cmpq $0x0, (%rbx)
jne 0x479ef7
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: percent_rankValueFunc
static void percent_rankValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal>1 ){
      double r = (double)(p->nValue-1) / (double)(p->nTotal-1);
      sqlite3_result_double(pCtx, r);
    }else{
      sqlite3_result_double(pCtx, 0.0);
    }
    p->nValue = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x479f22
movq %rbx, %rdi
movl $0x18, %esi
callq 0x40c613
movq %rax, %r14
jmp 0x479f26
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x479f62
movq 0x10(%r14), %rax
xorpd %xmm0, %xmm0
cmpq $0x2, %rax
jl 0x479f53
movq (%r14), %rcx
decq %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
decq %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movq (%rbx), %rdi
callq 0x40b16a
movq $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: cume_distStepFunc
static void cume_distStepFunc(
  sqlite3_context *pCtx, 
  int nArg,
  sqlite3_value **apArg
){
  struct CallCount *p;
  assert( nArg==1 ); UNUSED_PARAMETER(nArg);

  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nTotal = sqlite3_value_int64(apArg[0]);
    }
    p->nStep++;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x479f8a
movl $0x18, %esi
callq 0x40c613
movq %rax, %r14
jmp 0x479f8e
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x479faa
cmpq $0x0, 0x10(%r14)
jne 0x479fa6
movq (%rbx), %rdi
callq 0x40aeec
movq %rax, 0x10(%r14)
incq 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: cume_distValueFunc
static void cume_distValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->nTotal ){
    double r = (double)(p->nStep) / (double)(p->nTotal);
    sqlite3_result_double(pCtx, r);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x479fcf
movq %rbx, %rdi
movl $0x18, %esi
callq 0x40c613
jmp 0x479fd3
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x479ff9
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x479ff9
cvtsi2sdq 0x8(%rax), %xmm0
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm0
movq (%rbx), %rdi
popq %rbx
jmp 0x40b16a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: ntileStepFunc
static void ntileStepFunc(
  sqlite3_context *pCtx, 
  int nArg,
  sqlite3_value **apArg
){
  struct NtileCtx *p;
  assert( nArg==2 ); UNUSED_PARAMETER(nArg);
  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nParam = sqlite3_value_int64(apArg[0]);
      p->nTotal = sqlite3_value_int64(apArg[1]);
      if( p->nParam<=0 ){
        sqlite3_result_error(
            pCtx, "argument of ntile must be a positive integer", -1
        );
      }
    }
    p->iRow++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47a022
movq %rbx, %rdi
movl $0x18, %esi
callq 0x40c613
movq %rax, %r14
jmp 0x47a026
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x47a07b
cmpq $0x0, (%r14)
jne 0x47a077
movq (%r15), %rdi
callq 0x40aeec
movq %rax, 0x8(%r14)
movq 0x8(%r15), %rdi
callq 0x40aeec
movq %rax, (%r14)
cmpq $0x0, 0x8(%r14)
jg 0x47a077
movl $0x1, 0x24(%rbx)
movq (%rbx), %rdi
leaq 0xda922(%rip), %rsi     # 0x554983
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x40b1de
incq 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: last_valueValueFunc
static void last_valueValueFunc(sqlite3_context *pCtx){
  struct LastValueCtx *p;
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->pVal ){
    sqlite3_result_value(pCtx, p->pVal);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47a201
movq %rbx, %rdi
movl $0x10, %esi
callq 0x40c613
jmp 0x47a205
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x47a21b
movq (%rax), %rsi
testq %rsi, %rsi
je 0x47a21b
movq (%rbx), %rdi
popq %rbx
jmp 0x40b5bf
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/util.c
// Function: trim_space
char* trim_space(const char* s) {
  size_t start = 0;
  while (start < strlen(s) && isspace(s[start])) {
    start++;
  }
  size_t limit = strlen(s);
  while (limit > start && isspace(s[limit - 1])) {
    limit--;
  }

  char* res = calloc(sizeof(char), limit - start + 1);
  for (size_t i = 0; i < limit - start; i++)
    res[i] = s[start + i];
  res[limit - start] = '\0';

  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x401100
testq %rax, %rax
je 0x47c937
movq %rax, %r14
callq 0x47f6f0
movq (%rax), %rax
xorl %r12d, %r12d
movsbq (%rbx,%r12), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x47c93f
incq %r12
cmpq %r12, %r14
jne 0x47c91e
movq %r14, %r12
jmp 0x47c964
xorl %r12d, %r12d
xorl %r14d, %r14d
jmp 0x47c964
cmpq %r12, %r14
jbe 0x47c964
callq 0x47f6f0
movq (%rax), %rax
movsbq -0x1(%rbx,%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x47c964
decq %r14
cmpq %r12, %r14
ja 0x47c94c
movq %r12, %r14
movq %r14, %rax
subq %r12, %rax
leaq 0x1(%rax), %rsi
movl $0x1, %edi
callq 0x4a87e0
movq %rax, %r15
subq %r12, %r14
je 0x47c991
addq %r12, %rbx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x401048
movb $0x0, (%r15,%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O3/veltzer[P]xmeltdown/src/grid.c
// Function: main
int main(int argc, char** argv) {
	XGCValues my_gcvalues;
	XEvent my_event;
	int counter;

	Initialize(argc, argv);

	XSelectInput(dpy, win,
		ExposureMask|ButtonPressMask|ButtonReleaseMask|
		ButtonMotionMask|KeyPressMask);

	my_gcvalues.line_width=5;
	my_gcvalues.line_style=LineSolid;
	for (counter=0; counter < 16; counter++) {
		my_gcvalues.function=counter;

		gc_list[counter]=XCreateGC(dpy, win,
			GCFunction|GCLineWidth|GCLineStyle,
			&my_gcvalues);
	}
	while (1) {
		XNextEvent (dpy, &my_event);
		if (my_event.type == Expose)
			DrawGrid();
		if (my_event.type == ButtonPress)
			DrawGrid();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
callq 0x11dc
movq 0x2d26(%rip), %rdi      # 0x4090
movq 0x2d27(%rip), %rsi      # 0x4098
movl $0xa00d, %edx           # imm = 0xA00D
callq 0x10c0
leaq 0xc0(%rsp), %rbx
movq $0x5, 0x20(%rbx)
leaq 0x2d0e(%rip), %r14      # 0x40a0
xorl %r15d, %r15d
movl %r15d, 0xc0(%rsp)
movq 0x2cec(%rip), %rdi      # 0x4090
movq 0x2ced(%rip), %rsi      # 0x4098
movl $0x31, %edx
movq %rbx, %rcx
callq 0x10b0
movq %rax, (%r14)
incq %r15
addq $0x8, %r14
cmpq $0x10, %r15
jne 0x1395
movq %rsp, %rbx
movq 0x2cbe(%rip), %rdi      # 0x4090
movq %rbx, %rsi
callq 0x1090
movl (%rsp), %eax
cmpl $0xc, %eax
jne 0x13ea
callq 0x12c7
movl (%rsp), %eax
cmpl $0x4, %eax
jne 0x13cb
callq 0x12c7
jmp 0x13cb