LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowAggFinal
static void windowAggFinal(WindowCodeArg *p, int bFin){
  Parse *pParse = p->pParse;
  Window *pMWin = p->pMWin;
  Vdbe *v = sqlite3GetVdbe(pParse);
  Window *pWin;

  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    if( pMWin->regStartRowid==0
     && (pWin->pFunc->funcFlags & SQLITE_FUNC_MINMAX)
     && (pWin->eStart!=TK_UNBOUNDED)
    ){
      sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
      sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp);
      VdbeCoverage(v);
      sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult);
      sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
    }else if( pWin->regApp ){
      assert( pMWin->regStartRowid==0 );
    }else{
      int nArg = windowArgCount(pWin);
      if( bFin ){
        sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg);
        sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF);
        sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult);
        sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
      }else{
        sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult);
        sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq (%rdi), %rax
movq 0x8(%rdi), %r15
movq %rax, %rdi
callq 0x2645be
movq %rax, %r14
pushq $0x48
popq %rbp
pushq $-0x8
popq %r13
movq %r15, %r12
testq %r12, %r12
je 0x27ced9
cmpl $0x0, 0x84(%r15)
jne 0x27cdf3
movq 0x50(%r12), %rax
testb $0x10, 0x5(%rax)
je 0x27cdf3
cmpb $0x5a, 0x21(%r12)
jne 0x27ce85
cmpl $0x0, 0x68(%r12)
jne 0x27cecf
movq 0x70(%r12), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x27ce11
movl (%rax), %ecx
jmp 0x27ce13
xorl %ecx, %ecx
movl 0x5c(%r12), %edx
testl %ebx, %ebx
je 0x27ce61
movq %r14, %rdi
movl $0x9d, %esi
callq 0x24d51a
movq 0x50(%r12), %rsi
movq %r14, %rdi
movl %r13d, %edx
callq 0x26495f
movl 0x5c(%r12), %edx
movl 0x60(%r12), %ecx
movq %r14, %rdi
pushq $0x4d
popq %rsi
callq 0x24d51a
movl 0x5c(%r12), %ecx
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x24d51a
jmp 0x27cecf
movl 0x60(%r12), %r8d
movq %r14, %rdi
movl $0x9c, %esi
callq 0x24d51f
movq 0x50(%r12), %rsi
movq %r14, %rdi
movl %r13d, %edx
callq 0x26495f
jmp 0x27cecf
movl 0x60(%r12), %ecx
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x24d51a
movl 0x64(%r12), %edx
movq %r14, %rdi
pushq $0x21
popq %rsi
callq 0x265d5c
movl 0x60(%r12), %r8d
movl 0x64(%r12), %edx
movq %r14, %rdi
pushq $0x59
popq %rsi
xorl %ecx, %ecx
callq 0x24d51f
movl 0x90(%r14), %esi
addl $-0x2, %esi
movq %r14, %rdi
callq 0x2645f8
movq 0x40(%r12), %r12
jmp 0x27cdc9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowIfNewPeer
static void windowIfNewPeer(
  Parse *pParse,
  ExprList *pOrderBy,
  int regNew,                     /* First in array of new values */
  int regOld,                     /* First in array of old values */
  int addr                        /* Jump here */
){
  Vdbe *v = sqlite3GetVdbe(pParse);
  if( pOrderBy ){
    int nVal = pOrderBy->nExpr;
    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0);
    sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal);
    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
    sqlite3VdbeAddOp3(v, OP_Jump,
      sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1
    );
    VdbeCoverageEqNe(v);
    sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1);
  }else{
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
callq 0x2645be
movq %rax, %r15
testq %r13, %r13
je 0x27d5f3
movl %r12d, 0x4(%rsp)
movl (%r13), %r12d
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x270980
movq %rax, %r14
pushq $0x56
popq %rsi
movq %r15, %rdi
movl %ebx, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x24d51f
pushq $-0x9
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x26495f
movl 0x90(%r15), %edx
incl %edx
pushq $0x10
popq %rsi
movq %r15, %rdi
movl 0x4(%rsp), %ecx
movl %edx, %r8d
callq 0x24d51f
decl %r12d
pushq $0x4d
popq %rsi
movq %r15, %rdi
movl %ebp, %edx
movl %ebx, %ecx
movl %r12d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24d51f
pushq $0xb
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
movl %r12d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24d51a
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowReadPeerValues
static void windowReadPeerValues(
  WindowCodeArg *p,
  int csr,
  int reg
){
  Window *pMWin = p->pMWin;
  ExprList *pOrderBy = pMWin->pOrderBy;
  if( pOrderBy ){
    Vdbe *v = sqlite3GetVdbe(p->pParse);
    ExprList *pPart = pMWin->pPartition;
    int iColOff = pMWin->nBufferCol + (pPart ? pPart->nExpr : 0);
    int i;
    for(i=0; i<pOrderBy->nExpr; i++){
      sqlite3VdbeAddOp3(v, OP_Column, csr, iColOff+i, reg+i);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
movq 0x18(%r15), %r12
testq %r12, %r12
je 0x27dc47
movl %edx, %ebx
movl %esi, %ebp
movq (%rdi), %rdi
callq 0x2645be
movq %rax, %r14
movq 0x10(%r15), %rcx
movl 0x78(%r15), %eax
xorl %r13d, %r13d
movl $0x0, %r15d
testq %rcx, %rcx
je 0x27dc24
movl (%rcx), %r15d
addl %eax, %r15d
cmpl (%r12), %r13d
jge 0x27dc47
leal (%r15,%r13), %ecx
leal (%rbx,%r13), %r8d
movq %r14, %rdi
pushq $0x59
popq %rsi
movl %ebp, %edx
callq 0x24d51f
incl %r13d
jmp 0x27dc27
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeDistinct
static void codeDistinct(
  Parse *pParse,     /* Parsing and code generating context */
  int iTab,          /* A sorting index used to test for distinctness */
  int addrRepeat,    /* Jump to here if not distinct */
  int N,             /* Number of elements */
  int iMem           /* First element */
){
  Vdbe *v;
  int r1;

  v = pParse->pVdbe;
  r1 = sqlite3GetTempReg(pParse);
  sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
  sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
  sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, iMem, N);
  sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
  sqlite3ReleaseTempReg(pParse, r1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, %r13d
movl %esi, %ebx
movq 0x10(%rdi), %r14
movq %rdi, (%rsp)
callq 0x267d61
movl %eax, %ebp
pushq $0x1e
popq %rsi
movq %r14, %rdi
movl %ebx, %edx
movl %r13d, %ecx
movl %r12d, %r8d
movl %r15d, %r9d
callq 0x226fc2
pushq $0x5b
popq %rsi
movq %r14, %rdi
movl %r12d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x24d51f
movq %r14, %rdi
movl $0x82, %esi
movl %ebx, %edx
movl %ebp, %ecx
movl %r12d, %r8d
movl %r15d, %r9d
callq 0x226fc2
movslq 0x90(%r14), %rax
testq %rax, %rax
jle 0x27e094
movq 0x88(%r14), %rcx
imulq $0x18, %rax, %rax
movw $0x10, -0x16(%rcx,%rax)
testl %ebp, %ebp
je 0x27e0b7
movq (%rsp), %rax
movzbl 0x1f(%rax), %eax
cmpq $0x7, %rax
ja 0x27e0b7
leal 0x1(%rax), %ecx
movq (%rsp), %rdx
movb %cl, 0x1f(%rdx)
movl %ebp, 0xd4(%rdx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: makeSorterRecord
static int makeSorterRecord(
  Parse *pParse,
  SortCtx *pSort,
  Select *pSelect,
  int regBase,
  int nBase
){
  int nOBSat = pSort->nOBSat;
  Vdbe *v = pParse->pVdbe;
  int regOut = ++pParse->nMem;
  if( pSort->pDeferredRowLoad ){
    innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
  }
  sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
  return regOut;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl 0x8(%rsi), %r12d
movq 0x10(%rdi), %r15
movl 0x38(%rdi), %r14d
incl %r14d
movl %r14d, 0x38(%rdi)
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x27e46b
movq %rdx, %rsi
movq %rax, %rdx
callq 0x27dffc
addl %r12d, %ebp
subl %r12d, %ebx
pushq $0x5b
popq %rsi
movq %r15, %rdi
movl %ebp, %edx
movl %ebx, %ecx
movl %r14d, %r8d
callq 0x24d51f
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/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 = sqlite3Expr(db, TK_INTEGER, "1");
      if( pNew ){
        Expr *pWhere = pS->pWhere;
        SWAP(Expr, *pNew, *pExpr);
        pNew = sqlite3ExprAnd(pWalker->pParse, 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 0x27e555
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rdi), %r12
movq 0x38(%r12), %rcx
leaq 0x8(%rsp), %r15
movw $0x1, 0x24(%r15)
leaq 0x99(%rip), %rdx        # 0x27e564
movq %rdx, 0x8(%r15)
andq $0x0, 0x10(%r15)
movq %rcx, 0x28(%r15)
movq %rax, (%r15)
movq %r15, %rdi
callq 0x267f87
cmpw $0x0, 0x24(%r15)
pushq $0x1
popq %rbp
je 0x27e555
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x90817(%rip), %rdx     # 0x30ed12
movl $0x98, %esi
callq 0x25bd93
testq %rax, %rax
je 0x27e555
movq 0x30(%r12), %rdx
pushq $0x9
popq %r8
leaq 0x8(%rsp), %r9
movq %r8, %rcx
movq %r9, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r8, %rcx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r8, %rcx
movq %r14, %rdi
movq %r9, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq (%rbx), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x26119e
movq %rax, 0x30(%r12)
movw $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_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprNodeIsConstantOrGroupBy
static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
  ExprList *pGroupBy = pWalker->u.pGroupBy;
  int i;

  /* Check if pExpr is identical to any GROUP BY term. If so, consider
  ** it constant.  */
  for(i=0; i<pGroupBy->nExpr; i++){
    Expr *p = pGroupBy->a[i].pExpr;
    if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
      CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p);
      if( sqlite3IsBinary(pColl) ){
        return WRC_Prune;
      }
    }
  }

  /* Check if pExpr is a sub-select. If so, consider it variable. */
  if( ExprHasProperty(pExpr, EP_xIsSelect) ){
    pWalker->eCode = 0;
    return WRC_Abort;
  }

  return exprNodeIsConstant(pWalker, pExpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %r13
leaq 0x8(%r13), %rbp
xorl %r15d, %r15d
movslq (%r13), %rax
cmpq %rax, %r15
jge 0x27e5c8
movq (%rbp), %r12
xorl %edi, %edi
movq %rbx, %rsi
movq %r12, %rdx
pushq $-0x1
popq %rcx
callq 0x26823c
cmpl $0x1, %eax
ja 0x27e5bf
movq (%r14), %rdi
movq %r12, %rsi
callq 0x2765b9
testq %rax, %rax
je 0x27e5e7
leaq -0x80cc(%rip), %rcx     # 0x2764ed
cmpq %rcx, 0x18(%rax)
je 0x27e5e7
incq %r15
addq $0x18, %rbp
jmp 0x27e580
testb $0x8, 0x5(%rbx)
jne 0x27e5eb
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x267e9f
pushq $0x1
jmp 0x27e5f3
andw $0x0, 0x24(%r14)
pushq $0x2
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/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FkRequired
SQLITE_PRIVATE int sqlite3FkRequired(
  Parse *pParse,                  /* Parse context */
  Table *pTab,                    /* Table being modified */
  int *aChange,                   /* Non-NULL for UPDATE operations */
  int chngRowid                   /* True for UPDATE that affects rowid */
){
  int eRet = 0;
  if( pParse->db->flags&SQLITE_ForeignKeys ){
    if( !aChange ){
      /* A DELETE operation. Foreign key processing is required if the
      ** table in question is either the child or parent table for any
      ** foreign key constraint.  */
      eRet = (sqlite3FkReferences(pTab) || pTab->pFKey);
    }else{
      /* This is an UPDATE. Foreign key processing is only required if the
      ** operation modifies one or more child or parent key columns. */
      FKey *p;

      /* Check if any child key columns are being modified. */
      for(p=pTab->pFKey; p; p=p->pNextFrom){
        if( 0==sqlite3_stricmp(pTab->zName, p->zTo) ) return 2;
        if( fkChildIsModified(pTab, p, aChange, chngRowid) ){
          eRet = 1;
        }
      }

      /* Check if any parent key columns are being modified. */
      for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
        if( fkParentIsModified(pTab, p, aChange, chngRowid) ){
          if( p->aAction[1]!=OE_None ) return 2;
          eRet = 1;
        }
      }
    }
  }
  return eRet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
xorl %r13d, %r13d
testb $0x40, 0x31(%rax)
je 0x27ea61
movq %rdx, %r15
movq %rsi, %rbx
testq %rdx, %rdx
je 0x27ea15
movl %ecx, %r14d
leaq 0x20(%rbx), %r12
xorl %r13d, %r13d
pushq $0x1
popq %rbp
movq (%r12), %r12
testq %r12, %r12
je 0x27ea26
movq (%rbx), %rdi
movq 0x10(%r12), %rsi
callq 0x221763
testl %eax, %eax
je 0x27ea5d
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x27f1d5
testl %eax, %eax
cmovnel %ebp, %r13d
addq $0x8, %r12
jmp 0x27e9de
movq %rbx, %rdi
callq 0x270557
testq %rax, %rax
je 0x27ea73
pushq $0x1
jmp 0x27ea5f
movq %rbx, %rdi
callq 0x270557
movq %rax, %r12
testq %r12, %r12
je 0x27ea61
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x27f222
testl %eax, %eax
je 0x27ea56
cmpb $0x0, 0x2e(%r12)
movl %ebp, %r13d
jne 0x27ea5d
movq 0x18(%r12), %r12
jmp 0x27ea31
pushq $0x2
popq %r13
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
cmpq $0x0, 0x20(%rbx)
setne %r13b
jmp 0x27ea61
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IsReadOnly
SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
  if( tabIsReadOnly(pParse, pTab) ){
    sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
    return 1;
  }
#ifndef SQLITE_OMIT_VIEW
  if( !viewOk && pTab->pSelect ){
    sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
    return 1;
  }
#endif
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x54(%rsi)
je 0x27eacc
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x24ce25
movq 0x8(%rax), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x68(%rcx)
sete %al
testl %eax, %eax
je 0x27eaf1
movq (%r14), %rdx
leaq 0xfa654(%rip), %rsi     # 0x379111
movq %rbx, %rdi
xorl %eax, %eax
callq 0x226dce
pushq $0x1
popq %rax
jmp 0x27eaf7
movl 0x40(%r14), %eax
testw $0x1001, %ax            # imm = 0x1001
je 0x27eaf1
movq (%rbx), %rdi
testb $0x1, %al
jne 0x27eae4
callq 0x26a894
jmp 0x27eaaf
movl $0x10000001, %eax       # imm = 0x10000001
andl 0x30(%rdi), %eax
cmpl $0x1, %eax
jne 0x27eb0f
xorl %eax, %eax
testl %ebp, %ebp
je 0x27eafc
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x18(%r14)
je 0x27eaf7
movq (%r14), %rdx
leaq 0xfa621(%rip), %rsi     # 0x37912e
jmp 0x27eabd
xorl %eax, %eax
cmpb $0x0, 0x1e(%rbx)
jmp 0x27eaac
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3MaterializeView
SQLITE_PRIVATE void sqlite3MaterializeView(
  Parse *pParse,       /* Parsing context */
  Table *pView,        /* View definition */
  Expr *pWhere,        /* Optional WHERE clause to be added */
  ExprList *pOrderBy,  /* Optional ORDER BY clause */
  Expr *pLimit,        /* Optional LIMIT clause */
  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(pParse, 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].zDbSName);
    assert( pFrom->a[0].pOn==0 );
    assert( pFrom->a[0].pUsing==0 );
  }
  pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, pOrderBy,
                          SF_IncludeHidden, pLimit);
  sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
  sqlite3Select(pParse, pSel, &dest);
  sqlite3SelectDelete(db, pSel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x1c(%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x70(%rsi), %rsi
movq %rbx, %rdi
callq 0x226e9e
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x267197
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x25bf69
movq %rax, %r12
testq %rax, %rax
je 0x27eb96
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x22572a
movq %rax, 0x18(%r12)
movq 0x20(%rbx), %rax
movslq %ebp, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %rbx, %rdi
callq 0x22572a
movq %rax, 0x10(%r12)
andq $0x0, 0x10(%rsp)
andq $0x0, (%rsp)
movl $0x20000, 0x8(%rsp)     # imm = 0x20000
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x25bb53
leaq 0x20(%rsp), %rdx
movb $0xc, (%rdx)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rdx)
andl $0x0, 0x8(%rdx)
andq $0x0, 0x18(%rdx)
movq %rax, %r15
andq $0x0, 0xc(%rdx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x2565ce
movq %rbx, %rdi
movq %r15, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24b6e9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/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 = sqlite3Realloc(pToplevel->apVtabLock, n);
  if( apVtabLock ){
    pToplevel->apVtabLock = apVtabLock;
    pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
  }else{
    sqlite3OomFault(pToplevel->db);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xa0(%rdi), %r14
testq %r14, %r14
cmoveq %rdi, %r14
movl 0x120(%r14), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x27edd3
movq 0x178(%r14), %rsi
leaq 0x1(%rcx), %rdi
cmpq %rbx, (%rsi,%rcx,8)
movq %rdi, %rcx
jne 0x27edb8
jmp 0x27ee0a
leal 0x8(,%rax,8), %eax
movq 0x178(%r14), %rdi
movslq %eax, %rsi
callq 0x21f85c
testq %rax, %rax
je 0x27ee12
movq %rax, 0x178(%r14)
movslq 0x120(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x120(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x224bb1
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: checkColumnOverlap
static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){
  int e;
  if( pIdList==0 || NEVER(pEList==0) ) return 1;
  for(e=0; e<pEList->nExpr; e++){
    if( sqlite3IdListIndex(pIdList, pEList->a[e].zEName)>=0 ) return 1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
pushq $0x1
popq %rbx
jne 0x27f1c9
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
imulq $0x18, %rax, %r12
addq $0x18, %r12
leaq 0x18(%rcx), %r13
cmpq %r13, %r12
je 0x27f1c7
movq 0x10(%r14,%rcx), %rsi
movq %r15, %rdi
callq 0x26eac5
movq %r13, %rcx
testl %eax, %eax
js 0x27f1a8
jmp 0x27f1c9
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3TriggerStepSrc
SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(
  Parse *pParse,       /* The parsing context */
  TriggerStep *pStep   /* The trigger containing the target token */
){
  sqlite3 *db = pParse->db;
  SrcList *pSrc;                  /* SrcList to be returned */
  char *zName = sqlite3DbStrDup(db, pStep->zTarget);
  pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
  assert( pSrc==0 || pSrc->nSrc==1 );
  assert( zName || pSrc==0 );
  if( pSrc ){
    Schema *pSchema = pStep->pTrig->pSchema;
    pSrc->a[0].zName = zName;
    if( pSchema!=db->aDb[1].pSchema ){
      pSrc->a[0].pSchema = pSchema;
    }
    if( pStep->pFrom ){
      SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0);
      pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup);
    }
  }else{
    sqlite3DbFree(db, zName);
  }
  return pSrc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x18(%rsi), %rsi
movq %r14, %rdi
callq 0x22572a
movq %rax, %r13
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x25bf69
testq %rax, %rax
je 0x2807ee
movq %rax, %r12
movq 0x8(%r15), %rax
movq 0x28(%rax), %rax
movq %r13, 0x18(%r12)
movq 0x20(%r14), %rcx
cmpq 0x38(%rcx), %rax
je 0x2807c4
movq %rax, 0x8(%r12)
movq 0x20(%r15), %rsi
testq %rsi, %rsi
je 0x2807fc
movq %r14, %rdi
xorl %edx, %edx
callq 0x269ff5
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x25cca4
movq %r14, %rdi
movq %r13, %rsi
callq 0x21f26b
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: autoIncrementEnd
static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){
  AutoincInfo *p;
  Vdbe *v = pParse->pVdbe;
  sqlite3 *db = pParse->db;

  assert( v );
  for(p = pParse->pAinc; p; p = p->pNext){
    static const int iLn = VDBE_OFFSET_LINENO(2);
    static const VdbeOpList autoIncEnd[] = {
      /* 0 */ {OP_NotNull,     0, 2, 0},
      /* 1 */ {OP_NewRowid,    0, 0, 0},
      /* 2 */ {OP_MakeRecord,  0, 2, 0},
      /* 3 */ {OP_Insert,      0, 0, 0},
      /* 4 */ {OP_Close,       0, 0, 0}
    };
    VdbeOp *aOp;
    Db *pDb = &db->aDb[p->iDb];
    int iRec;
    int memId = p->regCtr;

    iRec = sqlite3GetTempReg(pParse);
    assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
    sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId);
    VdbeCoverage(v);
    sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
    aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
    if( aOp==0 ) break;
    aOp[0].p1 = memId+1;
    aOp[1].p2 = memId+1;
    aOp[2].p1 = memId-1;
    aOp[2].p3 = iRec;
    aOp[3].p2 = iRec;
    aOp[3].p3 = memId+1;
    aOp[3].p5 = OPFLAG_APPEND;
    sqlite3ReleaseTempReg(pParse, iRec);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x98(%rdi), %r13
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %rbx
movq (%r13), %r13
testq %r13, %r13
je 0x2814d4
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movslq 0x10(%r13), %r14
movl 0x14(%r13), %r15d
movq %r12, %rdi
callq 0x267d61
movl %eax, %ebp
leal 0x2(%r15), %edx
movl 0x90(%rbx), %ecx
addl $0x7, %ecx
movq %rbx, %rdi
pushq $0x37
popq %rsi
movl %r15d, %r8d
callq 0x24d51f
movl 0x10(%r13), %edx
shlq $0x5, %r14
movq 0x20(%rsp), %rax
movq 0x18(%rax,%r14), %rax
movq 0x68(%rax), %rcx
movq %r12, %rdi
xorl %esi, %esi
pushq $0x61
popq %r8
callq 0x2646bb
movq %rbx, %rdi
pushq $0x5
popq %rsi
leaq 0xf42b8(%rip), %rdx     # 0x375730
callq 0x226ff9
testq %rax, %rax
je 0x2814d4
leal 0x1(%r15), %ecx
movl %ecx, 0x4(%rax)
movl %ecx, 0x20(%rax)
decl %r15d
movl %r15d, 0x34(%rax)
movl %ebp, 0x3c(%rax)
movl %ebp, 0x50(%rax)
movl %ecx, 0x54(%rax)
movw $0x8, 0x4a(%rax)
testl %ebp, %ebp
je 0x2813ff
movq 0x8(%rsp), %rax
movzbl 0x1f(%rax), %eax
cmpq $0x7, %rax
ja 0x2813ff
leal 0x1(%rax), %ecx
movq 0x8(%rsp), %rdx
movb %cl, 0x1f(%rdx)
movl %ebp, 0xd4(%rdx,%rax,4)
jmp 0x2813ff
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprReferencesUpdatedColumn
SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(
  Expr *pExpr,    /* The expression to be checked */
  int *aiChng,    /* aiChng[x]>=0 if column x changed by the UPDATE */
  int chngRowid   /* True if UPDATE changes the rowid */
){
  Walker w;
  memset(&w, 0, sizeof(w));
  w.eCode = 0;
  w.xExprCallback = checkConstraintExprNode;
  w.u.aiCol = aiChng;
  sqlite3WalkExpr(&w, pExpr);
  if( !chngRowid ){
    testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
    w.eCode &= ~CKCNSTRNT_ROWID;
  }
  testcase( w.eCode==0 );
  testcase( w.eCode==CKCNSTRNT_COLUMN );
  testcase( w.eCode==CKCNSTRNT_ROWID );
  testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
  return w.eCode!=0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rdi, %rax
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
andq $0x0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
leaq 0x18cf(%rip), %rcx      # 0x282dd9
movq %rcx, 0x8(%r14)
movq %rsi, 0x28(%r14)
movq %r14, %rdi
movq %rax, %rsi
callq 0x267f87
movl 0x24(%r14), %eax
movl %eax, %ecx
andl $-0x3, %ecx
testl %ebx, %ebx
cmovnel %eax, %ecx
xorl %eax, %eax
testw %cx, %cx
setne %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: checkConstraintExprNode
static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_COLUMN ){
    assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
    if( pExpr->iColumn>=0 ){
      if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
        pWalker->eCode |= CKCNSTRNT_COLUMN;
      }
    }else{
      pWalker->eCode |= CKCNSTRNT_ROWID;
    }
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x5c, (%rsi)
jne 0x282e00
movswq 0x30(%rsi), %rcx
testq %rcx, %rcx
js 0x282df8
movq 0x28(%rdi), %rdx
movw $0x1, %ax
cmpl $0x0, (%rdx,%rcx,4)
jns 0x282dfc
jmp 0x282e00
movw $0x2, %ax
orw %ax, 0x24(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: autoIncBegin
static int autoIncBegin(
  Parse *pParse,      /* Parsing context */
  int iDb,            /* Index of the database holding pTab */
  Table *pTab         /* The table we are writing to */
){
  int memId = 0;      /* Register holding maximum rowid */
  assert( pParse->db->aDb[iDb].pSchema!=0 );
  if( (pTab->tabFlags & TF_Autoincrement)!=0
   && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0
  ){
    Parse *pToplevel = sqlite3ParseToplevel(pParse);
    AutoincInfo *pInfo;
    Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;

    /* Verify that the sqlite_sequence table exists and is an ordinary
    ** rowid table with exactly two columns.
    ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
    if( pSeqTab==0
     || !HasRowid(pSeqTab)
     || IsVirtual(pSeqTab)
     || pSeqTab->nCol!=2
    ){
      pParse->nErr++;
      pParse->rc = SQLITE_CORRUPT_SEQUENCE;
      return 0;
    }

    pInfo = pToplevel->pAinc;
    while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
    if( pInfo==0 ){
      pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
      if( pInfo==0 ) return 0;
      pInfo->pNext = pToplevel->pAinc;
      pToplevel->pAinc = pInfo;
      pInfo->pTab = pTab;
      pInfo->iDb = iDb;
      pToplevel->nMem++;                  /* Register to hold name of table */
      pInfo->regCtr = ++pToplevel->nMem;  /* Max rowid register */
      pToplevel->nMem +=2;       /* Rowid in sqlite_sequence + orig max val */
    }
    memId = pInfo->regCtr;
  }
  return memId;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testb $0x8, 0x40(%rdx)
je 0x28311b
movq %rdi, %rax
movq (%rdi), %rdi
testb $0x4, 0x2c(%rdi)
jne 0x28311b
movq %rdx, %r14
movl %esi, %ebp
movq 0xa0(%rax), %r15
testq %r15, %r15
cmoveq %rax, %r15
movq 0x20(%rdi), %rcx
movslq %esi, %rdx
shlq $0x5, %rdx
movq 0x18(%rcx,%rdx), %rcx
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
je 0x283111
testb $-0x80, 0x40(%rcx)
jne 0x283111
cmpl $0x0, 0x54(%rcx)
jne 0x283111
cmpw $0x2, 0x46(%rcx)
jne 0x283111
leaq 0x98(%r15), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x283128
cmpq %r14, 0x8(%rax)
jne 0x2830fe
movl 0x14(%rax), %ebx
jmp 0x28311b
incl 0x30(%rax)
movl $0x20b, 0x18(%rax)      # imm = 0x20B
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x18
popq %rsi
callq 0x22d205
testq %rax, %rax
je 0x28311b
movq 0x98(%r15), %rcx
movq %rcx, (%rax)
movq %rax, 0x98(%r15)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movl 0x38(%r15), %ecx
leal 0x2(%rcx), %ebx
movl %ebx, 0x14(%rax)
addl $0x4, %ecx
movl %ecx, 0x38(%r15)
jmp 0x28311b
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: xferCompatibleIndex
static int xferCompatibleIndex(Index *pDest, Index *pSrc){
  int i;
  assert( pDest && pSrc );
  assert( pDest->pTable!=pSrc->pTable );
  if( pDest->nKeyCol!=pSrc->nKeyCol || pDest->nColumn!=pSrc->nColumn ){
    return 0;   /* Different number of columns */
  }
  if( pDest->onError!=pSrc->onError ){
    return 0;   /* Different conflict resolution strategies */
  }
  for(i=0; i<pSrc->nKeyCol; i++){
    if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
      return 0;   /* Different columns indexed */
    }
    if( pSrc->aiColumn[i]==XN_EXPR ){
      assert( pSrc->aColExpr!=0 && pDest->aColExpr!=0 );
      if( sqlite3ExprCompare(0, pSrc->aColExpr->a[i].pExpr,
                             pDest->aColExpr->a[i].pExpr, -1)!=0 ){
        return 0;   /* Different expressions in the index */
      }
    }
    if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
      return 0;   /* Different sort orders */
    }
    if( sqlite3_stricmp(pSrc->azColl[i],pDest->azColl[i])!=0 ){
      return 0;   /* Different collating sequences */
    }
  }
  if( sqlite3ExprCompare(0, pSrc->pPartIdxWhere, pDest->pPartIdxWhere, -1) ){
    return 0;     /* Different WHERE clauses */
  }

  /* If no test above fails then the indices must be compatible */
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzwl 0x5e(%rdi), %eax
xorl %r15d, %r15d
cmpw 0x5e(%rsi), %ax
jne 0x28325c
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x60(%rdi), %eax
cmpw 0x60(%rsi), %ax
jne 0x28325c
movb 0x62(%rbx), %al
cmpb 0x62(%r14), %al
jne 0x28325c
pushq $0x4
popq %r12
xorl %r13d, %r13d
pushq $-0x1
popq %rbp
movzwl 0x5e(%r14), %eax
cmpq %rax, %r13
jae 0x283241
movq 0x8(%r14), %rax
movzwl (%rax,%r13,2), %eax
movq 0x8(%rbx), %rcx
cmpw (%rcx,%r13,2), %ax
jne 0x28323c
cmpw $-0x2, %ax
jne 0x283202
movq 0x50(%r14), %rax
movq (%rax,%r12,2), %rsi
movq 0x50(%rbx), %rax
movq (%rax,%r12,2), %rdx
xorl %r15d, %r15d
xorl %edi, %edi
movl %ebp, %ecx
callq 0x26823c
testl %eax, %eax
jne 0x28325c
movq 0x38(%r14), %rax
movb (%rax,%r13), %al
movq 0x38(%rbx), %rcx
cmpb (%rcx,%r13), %al
jne 0x28323c
movq 0x40(%r14), %rax
movq (%rax,%r13,8), %rdi
movq 0x40(%rbx), %rax
movq (%rax,%r13,8), %rsi
callq 0x221763
incq %r13
addq $0xc, %r12
movl $0x0, %r15d
testl %eax, %eax
je 0x2831be
jmp 0x28325c
xorl %r15d, %r15d
jmp 0x28325c
movq 0x48(%r14), %rsi
movq 0x48(%rbx), %rdx
pushq $-0x1
popq %rcx
xorl %edi, %edi
callq 0x26823c
xorl %r15d, %r15d
testl %eax, %eax
sete %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprSetHeight
static void exprSetHeight(Expr *p){
  int nHeight = 0;
  heightOfExpr(p->pLeft, &nHeight);
  heightOfExpr(p->pRight, &nHeight);
  if( ExprHasProperty(p, EP_xIsSelect) ){
    heightOfSelect(p->x.pSelect, &nHeight);
  }else if( p->x.pList ){
    heightOfExprList(p->x.pList, &nHeight);
    p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
  }
  p->nHeight = nHeight + 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
andl $0x0, 0xc(%rsp)
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x283296
movl 0x28(%rcx), %ecx
testl %ecx, %ecx
jle 0x283296
movl %ecx, 0xc(%rsp)
movl %ecx, %eax
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x2832ab
movl 0x28(%rcx), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0x4(%rbx), %ebp
btl $0xb, %ebp
movq 0x20(%rbx), %r14
jb 0x2832ed
testq %r14, %r14
je 0x283307
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x276581
movl (%r14), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x18, %rcx, %rdx
xorl %ecx, %ecx
cmpq %rax, %rdx
je 0x2832fc
movq 0x8(%r14,%rax), %rsi
orl 0x4(%rsi), %ecx
addq $0x18, %rax
jmp 0x2832da
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x27650a
jmp 0x283307
andl $0x200104, %ecx         # imm = 0x200104
orl %ebp, %ecx
movl %ecx, 0x4(%rbx)
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: setPragmaResultColumnNames
static void setPragmaResultColumnNames(
  Vdbe *v,                     /* The query under construction */
  const PragmaName *pPragma    /* The pragma */
){
  u8 n = pPragma->nPragCName;
  sqlite3VdbeSetNumCols(v, n==0 ? 1 : n);
  if( n==0 ){
    sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
  }else{
    int i, j;
    for(i=0, j=pPragma->iPragCName; i<n; i++, j++){
      sqlite3VdbeSetColName(v, i, COLNAME_NAME, pragCName[j], SQLITE_STATIC);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0xb(%rsi), %r15d
testl %r15d, %r15d
pushq $0x1
popq %rsi
cmovnel %r15d, %esi
callq 0x24d7d5
testl %r15d, %r15d
je 0x2833af
movzbl 0xa(%r14), %r12d
shll $0x3, %r12d
xorl %r14d, %r14d
leaq 0x1b2f2e(%rip), %r13    # 0x4362b0
cmpl %r14d, %r15d
je 0x2833a5
leaq (%r12,%r14,8), %rax
movq (%r13,%rax), %rcx
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x24d856
incq %r14
jmp 0x283382
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x24d856
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/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:
testq %rdi, %rdi
je 0x283429
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movzwl 0x28(%rcx), %eax
testl %esi, %esi
js 0x283422
andl $-0xd, %eax
shll $0x2, %esi
orl %eax, %esi
movw %si, 0x28(%rcx)
movl %esi, %eax
shrl $0x2, %eax
andl $0x3, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: getSafetyLevel
static u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){
                             /* 123456789 123456789 123 */
  static const char zText[] = "onoffalseyestruextrafull";
  static const u8 iOffset[] = {0, 1, 2,  4,    9,  12,  15,   20};
  static const u8 iLength[] = {2, 2, 3,  5,    3,   4,   5,    4};
  static const u8 iValue[] =  {1, 0, 0,  0,    1,   1,   3,    2};
                            /* on no off false yes true extra full */
  int i, n;
  if( sqlite3Isdigit(*z) ){
    return (u8)sqlite3Atoi(z);
  }
  n = sqlite3Strlen30(z);
  for(i=0; i<ArraySize(iLength); i++){
    if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0
     && (!omitFull || iValue[i]<=1)
    ){
      return iValue[i];
    }
  }
  return dflt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movzbl (%rdi), %eax
addq $-0x3a, %rax
cmpq $-0xa, %rax
jae 0x283588
movl %edx, 0x8(%rsp)
movq %r14, %rdi
callq 0x2211ac
movl %eax, %r15d
xorl %r13d, %r13d
leaq 0xf2760(%rip), %r12     # 0x375c88
leaq 0xf2751(%rip), %rbx     # 0x375c80
leaq 0xf229a(%rip), %rbp     # 0x3757d0
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
addq $0x6, %rax
movq %rax, 0x10(%rsp)
cmpq $0x8, %r13
je 0x283592
movzbl (%r13,%r12), %eax
cmpl %eax, %r15d
jne 0x283583
movzbl (%r13,%rbx), %edi
addq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x2217ad
testl %eax, %eax
jne 0x283583
cmpl $0x0, 0xc(%rsp)
je 0x2835a5
movl $0xfffffff8, %eax       # imm = 0xFFFFFFF8
addq %r13, %rax
cmpq 0x10(%rsp), %rax
jb 0x2835a5
incq %r13
jmp 0x283544
movq %r14, %rdi
callq 0x24b4af
jmp 0x283596
movl 0x8(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf26e4(%rip), %rax     # 0x375c90
movb (%r13,%rax), %al
jmp 0x283596
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/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*);
      sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0);
    }else if( c=='i' ){
      sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i);
    }else{
      goto skip_op_resultrow;
    }
  }
  sqlite3VdbeAddOp2(p, OP_ResultRow, iDest, i);
skip_op_resultrow:
  va_end(ap);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x283619
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, 0x10(%rsp)
movl %esi, %r15d
xorl %r12d, %r12d
pushq $0x45
popq %rbp
pushq $0x73
popq %r13
movzbl (%r14,%r12), %eax
cmpl $0x69, %eax
je 0x283675
cmpl $0x73, %eax
jne 0x2836ea
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x283690
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x28369e
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x2836c4
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x2836d2
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %r9
testq %r9, %r9
movl %r13d, %esi
pushq $0x48
popq %rax
cmovel %eax, %esi
leal (%r15,%r12), %ecx
andl $0x0, (%rsp)
movq %rbx, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x264609
jmp 0x2836e2
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %edx
leal (%r15,%r12), %ecx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x24d51a
incq %r12
jmp 0x283647
testl %eax, %eax
jne 0x2836ff
pushq $0x50
popq %rsi
movq %rbx, %rdi
movl %r15d, %edx
movl %r12d, %ecx
callq 0x24d51a
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaFunclistLine
static void pragmaFunclistLine(
  Vdbe *v,               /* The prepared statement being created */
  FuncDef *p,            /* A particular function definition */
  int isBuiltin,         /* True if this is a built-in function */
  int showInternFuncs    /* True if showing internal functions */
){
  for(; p; p=p->pNext){
    const char *zType;
    static const u32 mask =
        SQLITE_DETERMINISTIC |
        SQLITE_DIRECTONLY |
        SQLITE_SUBTYPE |
        SQLITE_INNOCUOUS |
        SQLITE_FUNC_INTERNAL
    ;
    static const char *azEnc[] = { 0, "utf8", "utf16le", "utf16be" };

    assert( SQLITE_FUNC_ENCMASK==0x3 );
    assert( strcmp(azEnc[SQLITE_UTF8],"utf8")==0 );
    assert( strcmp(azEnc[SQLITE_UTF16LE],"utf16le")==0 );
    assert( strcmp(azEnc[SQLITE_UTF16BE],"utf16be")==0 );

    if( p->xSFunc==0 ) continue;
    if( (p->funcFlags & SQLITE_FUNC_INTERNAL)!=0
     && showInternFuncs==0
    ){
      continue;
    }
    if( p->xValue!=0 ){
      zType = "w";
    }else if( p->xFinalize!=0 ){
      zType = "a";
    }else{
      zType = "s";
    }
    sqlite3VdbeMultiLoad(v, 1, "sissii",
       p->zName, isBuiltin,
       zType, azEnc[p->funcFlags&SQLITE_FUNC_ENCMASK],
       p->nArg,
       (p->funcFlags & mask) ^ SQLITE_INNOCUOUS
    );
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %r13
testq %r14, %r14
je 0x2837c9
cmpq $0x0, 0x18(%r14)
je 0x2837c0
movl 0x4(%r14), %r10d
testl %ebx, %ebx
jne 0x283750
movl %r10d, %eax
andl $0x40000, %eax          # imm = 0x40000
jne 0x2837c0
cmpq $0x0, 0x28(%r14)
leaq 0xb01b2(%rip), %r9      # 0x33390e
jne 0x283775
cmpq $0x0, 0x20(%r14)
leaq 0x7efe6(%rip), %r9      # 0x302750
leaq 0x77ef8(%rip), %rax     # 0x2fb669
cmoveq %rax, %r9
movq 0x38(%r14), %rcx
movl %r10d, %r11d
andl $0x3, %r11d
movsbl (%r14), %r12d
andl $0x3c0800, %r10d        # imm = 0x3C0800
xorl $0x200000, %r10d        # imm = 0x200000
subq $0x8, %rsp
movq %r15, %rdi
movl %r13d, %esi
leaq 0xf5e93(%rip), %rdx     # 0x379636
movl %ebp, %r8d
xorl %eax, %eax
pushq %r10
pushq %r12
leaq 0x1b365d(%rip), %r10    # 0x436e10
pushq (%r10,%r11,8)
callq 0x2835b3
addq $0x20, %rsp
movq 0x10(%r14), %r14
jmp 0x28372a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: integrityCheckResultRow
static int integrityCheckResultRow(Vdbe *v){
  int addr;
  sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
  addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1);
  VdbeCoverage(v);
  sqlite3VdbeAddOp0(v, OP_Halt);
  return addr;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x50
popq %rsi
pushq $0x3
popq %rdx
pushq $0x1
popq %rbp
movl %ebp, %ecx
callq 0x24d51a
movl 0x90(%rbx), %ecx
addl $0x2, %ecx
pushq $0x30
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movl %ebp, %r8d
callq 0x24d51f
movl %eax, %ebp
pushq $0x44
popq %rsi
movq %rbx, %rdi
callq 0x2645ec
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: triggerStepAllocate
static TriggerStep *triggerStepAllocate(
  Parse *pParse,              /* Parser context */
  u8 op,                      /* Trigger opcode */
  Token *pName,               /* The target name */
  const char *zStart,         /* Start of SQL text */
  const char *zEnd            /* End of SQL text */
){
  sqlite3 *db = pParse->db;
  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;
    pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
    if( IN_RENAME_OBJECT ){
      sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName);
    }
  }
  return pTriggerStep;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movq (%rdi), %rbp
movl 0x8(%rdx), %esi
addq $0x61, %rsi
movq %rbp, %rdi
callq 0x2258ed
movq %rax, %r13
testq %rax, %rax
je 0x283a0b
movq %r15, 0x10(%rsp)
movq %r13, %r15
addq $0x60, %r15
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %r15, %rdi
callq 0x17630
movq %r15, %rdi
callq 0x26f55e
movq %r15, 0x18(%r13)
movl 0xc(%rsp), %eax
movb %al, (%r13)
movq %rbp, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
callq 0x283a1d
movq %rax, 0x48(%r13)
cmpb $0x2, 0x11c(%r14)
jb 0x283a0b
movq 0x18(%r13), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25c05b
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: triggerSpanDup
static char *triggerSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){
  char *z = sqlite3DbSpanDup(db, zStart, zEnd);
  int i;
  if( z ) for(i=0; z[i]; i++) if( sqlite3Isspace(z[i]) ) z[i] = ' ';
  return z;
}

// Assembly:
pushq %rax
callq 0x26f5b0
testq %rax, %rax
je 0x283a48
leaq 0xede21(%rip), %rcx     # 0x371850
movq %rax, %rdx
movzbl (%rdx), %esi
testq %rsi, %rsi
je 0x283a48
testb $0x1, (%rsi,%rcx)
je 0x283a43
movb $0x20, (%rdx)
incq %rdx
jmp 0x283a32
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SchemaGet
SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
  Schema * p;
  if( pBt ){
    p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
  }else{
    p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
  }
  if( !p ){
    sqlite3OomFault(db);
  }else if ( 0==p->file_format ){
    sqlite3HashInit(&p->tblHash);
    sqlite3HashInit(&p->idxHash);
    sqlite3HashInit(&p->trigHash);
    sqlite3HashInit(&p->fkeyHash);
    p->enc = SQLITE_UTF8;
  }
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2844f0
leaq -0x404c7(%rip), %rdx    # 0x24401a
pushq $0x78
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x22fead
jmp 0x2844fa
pushq $0x78
popq %rsi
xorl %edi, %edi
callq 0x2258ed
movq %rax, %r14
testq %rax, %rax
je 0x284531
cmpb $0x0, 0x70(%r14)
jne 0x284539
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movb $0x1, 0x71(%r14)
jmp 0x284539
movq %rbx, %rdi
callq 0x224bb1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq