LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/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 iAutoidxCur     /* If non-zero, cursor of autoindex being generated */
){
  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( iAutoidxCur ){
        pOp->opcode = OP_Sequence;
        pOp->p1 = iAutoidxCur;
      }else{
        pOp->opcode = OP_Null;
        pOp->p1 = 0;
        pOp->p3 = 0;
      }
    }
  }
}

// Assembly:
movq 0x10(%rdi), %r9
movl %esi, %eax
testl %esi, %esi
jns 0x2dcff9
movl 0x90(%r9), %eax
decl %eax
movq (%r9), %r10
cmpb $0x0, 0x61(%r10)
je 0x2dd00c
leaq 0x1e1e7e(%rip), %rax    # 0x4bee88
jmp 0x2dd01d
cltq
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x88(%r9), %rax
movl 0x90(%r9), %r9d
movq (%rdi), %rdi
cmpb $0x0, 0x61(%rdi)
sete %dil
subl %esi, %r9d
setg %sil
andb %dil, %sil
cmpb $0x1, %sil
jne 0x2dd08d
xorl %esi, %esi
cmpl %edx, 0x4(%rax)
jne 0x2dd084
movzbl (%rax), %edi
cmpl $0x7f, %edi
je 0x2dd06d
cmpl $0x59, %edi
jne 0x2dd084
movb $0x4d, (%rax)
movl 0x8(%rax), %edi
addl %ecx, %edi
movl %edi, 0x4(%rax)
movl 0xc(%rax), %edi
movl %edi, 0x8(%rax)
movl $0x0, 0xc(%rax)
jmp 0x2dd084
testl %r8d, %r8d
je 0x2dd07b
movb $0x77, (%rax)
movl %r8d, 0x4(%rax)
jmp 0x2dd084
movb $0x48, (%rax)
movl %esi, 0x4(%rax)
movl %esi, 0xc(%rax)
addq $0x18, %rax
decl %r9d
jne 0x2dd041
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeExprOrVector
static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){
  assert( nReg>0 );
  if( p && sqlite3ExprIsVector(p) ){
#ifndef SQLITE_OMIT_SUBQUERY
    if( (p->flags & EP_xIsSelect) ){
      Vdbe *v = pParse->pVdbe;
      int iSelect;
      assert( p->op==TK_SELECT );
      iSelect = sqlite3CodeSubselect(pParse, p);
      sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
    }else
#endif
    {
      int i;
      ExprList *pList = p->x.pList;
      assert( nReg<=pList->nExpr );
      for(i=0; i<nReg; i++){
        sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
      }
    }
  }else{
    assert( nReg==1 );
    sqlite3ExprCode(pParse, p, iReg);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
testq %rsi, %rsi
je 0x2ddbd7
movl %ecx, %ebp
movb (%rsi), %al
cmpb $-0x53, %al
jne 0x2ddbb4
movb 0x2(%rsi), %al
movq %rsi, %rcx
cmpb $-0x52, %al
je 0x2ddbc9
movzbl %al, %eax
cmpl $0x88, %eax
jne 0x2ddbd2
movq 0x20(%rsi), %rcx
movq 0x20(%rcx), %rax
cmpl $0x1, (%rax)
jg 0x2ddbf1
movq %r14, %rdi
jmp 0x2ddbdc
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2bc7e9
testb $0x8, 0x5(%rsi)
jne 0x2ddc35
testl %ebp, %ebp
jle 0x2ddc26
movq 0x20(%rsi), %r15
movl %ebp, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movq 0x8(%r15,%r13), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x2bc7e9
incl %ebx
addq $0x18, %r13
cmpq %r13, %r12
jne 0x2ddc0c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x2bef39
decl %ebp
movq %r15, %rdi
movl $0x4d, %esi
movl %eax, %edx
movl %ebx, %ecx
movl %ebp, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a83e1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: disableTerm
static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
  int nLoop = 0;
  assert( pTerm!=0 );
  while( (pTerm->wtFlags & TERM_CODED)==0
      && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
      && (pLevel->notReady & pTerm->prereqAll)==0
  ){
    if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
      pTerm->wtFlags |= TERM_LIKECOND;
    }else{
      pTerm->wtFlags |= TERM_CODED;
    }
    if( pTerm->iParent<0 ) break;
    pTerm = &pTerm->pWC->a[pTerm->iParent];
    assert( pTerm!=0 );
    pTerm->nChild--;
    if( pTerm->nChild!=0 ) break;
    nLoop++;
  }
}

// Assembly:
movzwl 0x12(%rsi), %r8d
testb $0x4, %r8b
jne 0x2ddce0
leaq 0x12(%rsi), %r9
movl (%rdi), %eax
xorl %ecx, %ecx
movl $0x4, %edx
testl %eax, %eax
je 0x2ddc8b
movq (%rsi), %r10
testb $0x1, 0x4(%r10)
je 0x2ddce0
movq 0x38(%rsi), %r10
testq %r10, 0x58(%rdi)
jne 0x2ddce0
btl $0xa, %r8d
movl $0x200, %r10d           # imm = 0x200
cmovael %edx, %r10d
subl $0x1, %ecx
cmovbl %edx, %r10d
orl %r8d, %r10d
movw %r10w, (%r9)
movslq 0x18(%rsi), %r8
testq %r8, %r8
js 0x2ddce0
movq 0x8(%rsi), %rsi
movq 0x20(%rsi), %rsi
shlq $0x6, %r8
decb 0x16(%rsi,%r8)
jne 0x2ddce0
addq %r8, %rsi
leaq 0x12(%rsi), %r9
movzwl 0x12(%rsi), %r8d
testb $0x4, %r8b
je 0x2ddc7d
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: updateRangeAffinityStr
static void updateRangeAffinityStr(
  Expr *pRight,                   /* RHS of comparison */
  int n,                          /* Number of vector elements in comparison */
  char *zAff                      /* Affinity string to modify */
){
  int i;
  for(i=0; i<n; i++){
    Expr *p = sqlite3VectorFieldSubexpr(pRight, i);
    if( sqlite3CompareAffinity(p, zAff[i])==SQLITE_AFF_BLOB
     || sqlite3ExprNeedsNoAffinityChange(p, zAff[i])
    ){
      zAff[i] = SQLITE_AFF_BLOB;
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x2ddd40
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r13d
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x2c0855
movq %rax, %r12
movsbl (%rbx,%r15), %esi
movq %rax, %rdi
callq 0x2c0948
cmpb $0x41, %al
je 0x2ddd2a
movsbl (%rbx,%r15), %esi
movq %r12, %rdi
callq 0x2de0e0
testl %eax, %eax
je 0x2ddd2f
movb $0x41, (%rbx,%r15)
incq %r15
cmpq %r15, %r13
jne 0x2ddcfa
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/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 and SQLITE_AFF_NONE
  ** entries at the beginning and end of the affinity string.
  */
  assert( SQLITE_AFF_NONE<SQLITE_AFF_BLOB );
  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 0x2dddc1
movl %edx, %eax
movq %rdi, %rbx
testl %edx, %edx
jle 0x2ddd75
movl %eax, %r14d
addq %rcx, %r14
leal (%rax,%rsi), %edx
cmpb $0x41, (%rcx)
jg 0x2ddd75
leal -0x1(%rax), %edi
incl %esi
incq %rcx
cmpl $0x1, %eax
movl %edi, %eax
jg 0x2ddd5d
xorl %eax, %eax
jmp 0x2ddd7a
movq %rcx, %r14
movl %esi, %edx
movl %eax, %eax
movq %rax, %r15
cmpl $0x2, %r15d
jl 0x2ddd93
leaq -0x1(%r15), %rax
cmpb $0x42, -0x1(%r14,%r15)
jl 0x2ddd7c
jmp 0x2ddd99
cmpq $0x1, %r15
jne 0x2dddc1
movq %rbx, %rdi
movl $0x5a, %esi
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %r15d, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x27b778
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/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 );

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x10(%rbx), %r13
orb $0x1, 0x44(%rdi)
movq %r13, %rdi
movl $0x85, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x2a83e1
testb $0x20, 0x3c(%r14)
je 0x2dde12
movq 0xa0(%rbx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
cmpl $0x0, 0x70(%rax)
je 0x2dde21
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %r14
movq (%rbx), %rdi
movswq 0x46(%r14), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x279b27
testq %rax, %rax
je 0x2dde12
movq %rax, %r15
movq %r13, (%rsp)
movswl 0x46(%r14), %eax
movl %eax, (%r15)
movzwl 0x60(%r12), %r13d
cmpq $0x2, %r13
jb 0x2dde8e
decl %r13d
movq 0x8(%r12), %r12
xorl %ebx, %ebx
movswl (%r12,%rbx,2), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x2be097
testl %ebp, %ebp
js 0x2dde86
movswq %ax, %rax
incq %rbx
movl %ebx, 0x4(%r15,%rax,4)
jmp 0x2dde89
incq %rbx
cmpq %r13, %rbx
jne 0x2dde65
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
movl $0xfffffff1, %ecx       # imm = 0xFFFFFFF1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27b778
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereApplyPartialIndexConstraints
static void whereApplyPartialIndexConstraints(
  Expr *pTruth,
  int iTabCur,
  WhereClause *pWC
){
  int i;
  WhereTerm *pTerm;
  while( pTruth->op==TK_AND ){
    whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC);
    pTruth = pTruth->pRight;
  }
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr;
    if( pTerm->wtFlags & TERM_CODED ) continue;
    pExpr = pTerm->pExpr;
    if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
      pTerm->wtFlags |= TERM_CODED;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x2c, (%rdi)
jne 0x2de09b
movq 0x10(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x2de06e
movq 0x18(%r14), %r14
cmpb $0x2c, (%r14)
je 0x2de083
cmpl $0x0, 0x14(%rbx)
jle 0x2de0d7
movq 0x20(%rbx), %r15
addq $0x12, %r15
xorl %r12d, %r12d
testb $0x4, (%r15)
jne 0x2de0ca
movq -0x12(%r15), %rsi
xorl %edi, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2c0d98
testl %eax, %eax
jne 0x2de0ca
orb $0x4, (%r15)
incl %r12d
addq $0x40, %r15
cmpl 0x14(%rbx), %r12d
jl 0x2de0ac
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprNeedsNoAffinityChange
SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
  u8 op;
  int unaryMinus = 0;
  if( aff==SQLITE_AFF_BLOB ) return 1;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
    if( p->op==TK_UMINUS ) unaryMinus = 1;
    p = p->pLeft;
  }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_FLOAT: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_STRING: {
      return !unaryMinus && aff==SQLITE_AFF_TEXT;
    }
    case TK_BLOB: {
      return !unaryMinus;
    }
    case TK_COLUMN: {
      assert( p->iTable>=0 );  /* p cannot be part of a CHECK constraint */
      return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0;
    }
    default: {
      return 0;
    }
  }
}

// Assembly:
movl $0x1, %eax
cmpb $0x41, %sil
jne 0x2de0ec
retq
xorl %ecx, %ecx
movb (%rdi), %dl
movzbl %dl, %r8d
leal -0xaa(%r8), %r9d
cmpl $0x2, %r9d
jae 0x2de10d
cmpb $-0x56, %dl
cmovel %eax, %ecx
movq 0x10(%rdi), %rdi
jmp 0x2de0ee
cmpl $0xad, %r8d
jne 0x2de119
movb 0x2(%rdi), %dl
movzbl %dl, %edx
xorl %eax, %eax
cmpl $0x96, %edx
jle 0x2de140
cmpl $0x97, %edx
je 0x2de157
cmpl $0xa4, %edx
je 0x2de15f
cmpl $0x98, %edx
je 0x2de14d
jmp 0x2de0eb
cmpl $0x73, %edx
je 0x2de16d
cmpl $0x96, %edx
jne 0x2de0eb
xorl %eax, %eax
cmpb $0x43, %sil
setge %al
retq
xorl %eax, %eax
testl %ecx, %ecx
sete %al
retq
cmpb $0x43, %sil
jl 0x2de0eb
movzwl 0x30(%rdi), %eax
shrl $0xf, %eax
retq
testl %ecx, %ecx
sete %al
cmpb $0x42, %sil
sete %cl
andb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/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 ){
    preserveExpr(pX, pExpr);
    pExpr->affExpr = sqlite3ExprAffinity(pExpr);
    pExpr->op = TK_COLUMN;
    pExpr->iTable = pX->iIdxCur;
    pExpr->iColumn = pX->iIdxCol;
    pExpr->y.pTab = 0;
    testcase( ExprHasProperty(pExpr, EP_Skip) );
    testcase( ExprHasProperty(pExpr, EP_Unlikely) );
    ExprClearProperty(pExpr, EP_Skip|EP_Unlikely);
    return WRC_Prune;
  }else{
    return WRC_Continue;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rdi), %r14
movq (%r14), %rdx
movl 0x8(%r14), %ecx
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x2c0d98
testl %eax, %eax
jne 0x2de1de
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2de258
movq %rbx, %rdi
callq 0x2c08a4
movb %al, 0x1(%rbx)
movb $-0x5c, (%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r14), %eax
movw %ax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
andl $0xfffbefff, 0x4(%rbx)  # imm = 0xFFFBEFFF
movl $0x1, %r15d
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereIndexExprTransColumn
static int whereIndexExprTransColumn(Walker *p, Expr *pExpr){
  if( pExpr->op==TK_COLUMN ){
    IdxExprTrans *pX = p->u.pIdxTrans;
    if( pExpr->iTable==pX->iTabCur && pExpr->iColumn==pX->iTabCol ){
      assert( pExpr->y.pTab!=0 );
      preserveExpr(pX, pExpr);
      pExpr->affExpr = sqlite3TableColumnAffinity(pExpr->y.pTab,pExpr->iColumn);
      pExpr->iTable = pX->iIdxCur;
      pExpr->iColumn = pX->iIdxCol;
      pExpr->y.pTab = 0;
    }
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x5c, (%rsi)
jne 0x2de255
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %r14
movl 0x2c(%rsi), %eax
cmpl 0x8(%r14), %eax
jne 0x2de24e
movswl 0x30(%rbx), %eax
cmpl %eax, 0x14(%r14)
jne 0x2de24e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2de258
movswq 0x30(%rbx), %rax
testq %rax, %rax
js 0x2de231
movq 0x40(%rbx), %rcx
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movb 0x19(%rcx,%rax), %al
jmp 0x2de233
movb $0x44, %al
movb %al, 0x1(%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r14), %eax
movw %ax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: preserveExpr
static void preserveExpr(IdxExprTrans *pTrans, Expr *pExpr){
  WhereExprMod *pNew;
  pNew = sqlite3DbMallocRaw(pTrans->db, sizeof(*pNew));
  if( pNew==0 ) return;
  pNew->pNext = pTrans->pWInfo->pExprMods;
  pTrans->pWInfo->pExprMods = pNew;
  pNew->pExpr = pExpr;
  memcpy(&pNew->orig, pExpr, sizeof(*pExpr));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x2de277
movl $0x58, %esi
callq 0x282a35
jmp 0x2de281
movl $0x58, %edi
callq 0x272ae6
testq %rax, %rax
je 0x2de2ab
movq 0x18(%r14), %rcx
movq 0x58(%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x58(%rcx)
movq %rbx, 0x8(%rax)
addq $0x10, %rax
movl $0x9, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowExprGtZero
static int windowExprGtZero(Parse *pParse, Expr *pExpr){
  int ret = 0;
  sqlite3 *db = pParse->db;
  sqlite3_value *pVal = 0;
  sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
  if( pVal && sqlite3_value_int(pVal)>0 ){
    ret = 1;
  }
  sqlite3ValueFree(pVal);
  return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rsi, %rsi
je 0x2de39a
movzbl 0x5e(%rdi), %edx
movq %rsp, %rbx
movl $0x43, %ecx
movq %rbx, %r8
callq 0x2c0365
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2de39a
movq %rbx, %rdi
callq 0x27828c
xorl %ebp, %ebp
testl %eax, %eax
setg %bpl
jmp 0x2de39e
xorl %ebx, %ebx
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x278453
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bc630
movq %rax, %r15
testq %r13, %r13
je 0x2def88
movl %r12d, 0x4(%rsp)
movl (%r13), %r12d
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cde19
movq %rax, %r13
movq %r15, %rdi
movl $0x56, %esi
movl %ebx, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x2a83e1
movq (%r15), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2def9a
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
movq %r13, %rdx
callq 0x28fb69
jmp 0x2defb6
movq %r15, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
jmp 0x2defe5
movq 0x88(%r15), %rax
movslq 0x90(%r15), %rcx
leaq (%rcx,%rcx,2), %rcx
movb $-0x9, -0x17(%rax,%rcx,8)
movq %r13, -0x8(%rax,%rcx,8)
movl 0x90(%r15), %edx
incl %edx
movq %r15, %rdi
movl $0x10, %esi
movl 0x4(%rsp), %ecx
movl %edx, %r8d
callq 0x2a83e1
decl %r12d
movq %r15, %rdi
movl $0x4d, %esi
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 0x2a83e1
// File: /workspace/github_c_makefile_star2_O3/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), %r13
movq 0x18(%r13), %r15
testq %r15, %r15
je 0x2df7b8
movl %edx, %ebx
movl %esi, %ebp
movq (%rdi), %rdi
callq 0x2bc630
movq %rax, %r14
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x2df789
movl (%rax), %r12d
jmp 0x2df78c
xorl %r12d, %r12d
cmpl $0x0, (%r15)
jle 0x2df7b8
addl 0x78(%r13), %r12d
xorl %r13d, %r13d
leal (%r12,%r13), %ecx
leal (%rbx,%r13), %r8d
movq %r14, %rdi
movl $0x59, %esi
movl %ebp, %edx
callq 0x2a83e1
incl %r13d
cmpl (%r15), %r13d
jl 0x2df799
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ecx
movl %esi, %r13d
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movb 0x1f(%rdi), %al
testb %al, %al
je 0x2dfd86
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xd4(%rbx,%rax,4), %ebp
jmp 0x2dfd8e
movl 0x38(%rbx), %ebp
incl %ebp
movl %ebp, 0x38(%rbx)
movq %r14, %rdi
movl $0x1e, %esi
movl %r13d, %edx
movl %r12d, %r8d
callq 0x2a83e1
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
jne 0x2dfdc1
movq 0x88(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
movb $-0x3, 0x1(%rcx,%rax,8)
movl %r15d, 0x10(%rcx,%rax,8)
movq %r14, %rdi
movl $0x5b, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl $0x82, %esi
movl %r13d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x2a83e1
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
jne 0x2dfe0c
movq 0x88(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
movb $-0x3, 0x1(%rcx,%rax,8)
movl %r15d, 0x10(%rcx,%rax,8)
movslq 0x90(%r14), %rax
testq %rax, %rax
jle 0x2dfe2a
movq 0x88(%r14), %rcx
leaq (%rax,%rax,2), %rax
movw $0x10, -0x16(%rcx,%rax,8)
testl %ebp, %ebp
je 0x2dfe45
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x2dfe45
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xd4(%rbx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e0346
movq 0x20(%rdx), %rsi
movl (%rax), %edx
movzbl 0x4(%rax), %r8d
xorl %ecx, %ecx
callq 0x2beb59
addl %r12d, %ebp
subl %r12d, %ebx
movq %r15, %rdi
movl $0x5b, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl %r14d, %r8d
callq 0x2a83e1
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e044a
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 0xb1(%rip), %rdx        # 0x2e0459
movq %rdx, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq %rcx, 0x28(%r15)
movq %rax, (%r15)
movq %r15, %rdi
callq 0x2c0a8c
cmpw $0x0, 0x24(%r15)
movl $0x1, %ebp
je 0x2e044a
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x8e61d(%rip), %rax     # 0x36e9fa
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rdx)
movl $0x98, %esi
xorl %ecx, %ecx
callq 0x2b1c27
testq %rax, %rax
je 0x2e044a
movq 0x30(%r12), %rdx
leaq 0x8(%rsp), %r8
movl $0x9, %ecx
movq %r8, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x9, %ecx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x9, %ecx
movq %r14, %rdi
movq %r8, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq (%rbx), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2b6b0e
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_O3/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, (%rsp)
movq 0x28(%rdi), %r13
cmpl $0x0, (%r13)
jle 0x2e04d9
leaq 0x8(%r13), %rbp
xorl %r14d, %r14d
movq (%rbp), %r15
xorl %edi, %edi
movq %rbx, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2c0d98
cmpl $0x1, %eax
ja 0x2e04c9
movq (%rsp), %rax
movq (%rax), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2a9678
testq %rax, %rax
jne 0x2e04bc
movq (%r12), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2e050a
leaq -0xca63(%rip), %rcx     # 0x2d3a60
cmpq %rcx, 0x18(%rax)
je 0x2e050a
incq %r14
movslq (%r13), %rax
addq $0x18, %rbp
cmpq %rax, %r14
jl 0x2e047d
testb $0x8, 0x5(%rbx)
jne 0x2e04f9
movq (%rsp), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c0987
movq (%rsp), %rax
movw $0x0, 0x24(%rax)
movl $0x2, %eax
jmp 0x2e050f
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/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 %r12
pushq %rbx
xorl %r15d, %r15d
btl $0xe, %edi
jae 0x2e0a14
movq %rdx, %r14
movq %rsi, %rbx
testq %rdx, %rdx
je 0x2e099d
movl %ecx, %ebp
movq (%rbx), %rsi
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x2e09ca
xorl %edx, %edx
leaq 0xf09d3(%rip), %rcx     # 0x3d12e0
movq 0x10(%rax), %rdi
testq %rsi, %rsi
je 0x2e0946
testq %rdi, %rdi
je 0x2e094f
xorl %r8d, %r8d
movzbl (%rsi,%r8), %r9d
movzbl (%rdi,%r8), %r10d
cmpb %r10b, %r9b
jne 0x2e0937
testq %r9, %r9
jne 0x2e0941
jmp 0x2e0a0e
movb (%r9,%rcx), %r9b
cmpb (%r10,%rcx), %r9b
jne 0x2e094f
incq %r8
jmp 0x2e091e
testq %rdi, %rdi
je 0x2e0a0e
movslq 0x28(%rax), %rdi
testq %rdi, %rdi
jle 0x2e0988
shlq $0x4, %rdi
xorl %r8d, %r8d
movslq 0x40(%rax,%r8), %r9
movl $0x1, %r15d
cmpl $0x0, (%r14,%r9,4)
jns 0x2e098b
testl %ebp, %ebp
je 0x2e097f
movswl 0x44(%rbx), %r10d
cmpl %r10d, %r9d
je 0x2e098b
addq $0x10, %r8
cmpq %r8, %rdi
jne 0x2e095f
movl %edx, %r15d
movq 0x8(%rax), %rax
movl %r15d, %edx
testq %rax, %rax
jne 0x2e090d
jmp 0x2e09cd
movq (%rbx), %rsi
movq 0x70(%rbx), %rdi
addq $0x50, %rdi
xorl %edx, %edx
callq 0x2a547e
movl $0x1, %r15d
cmpq $0x0, 0x10(%rax)
jne 0x2e0a14
xorl %r15d, %r15d
cmpq $0x0, 0x20(%rbx)
setne %r15b
jmp 0x2e0a14
xorl %r15d, %r15d
movq 0x70(%rbx), %rdi
addq $0x50, %rdi
xorl %edx, %edx
callq 0x2a547e
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x2e0a14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2e12a3
testl %eax, %eax
je 0x2e0a07
movl $0x1, %r15d
cmpb $0x0, 0x2e(%r12)
jne 0x2e0a0e
movq 0x18(%r12), %r12
jmp 0x2e09e0
movl $0x2, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
cmpl $0x0, 0x54(%rsi)
je 0x2e0a51
movq (%rdi), %rax
leaq 0x60(%rsi), %rcx
movq (%rcx), %r8
leaq 0x28(%r8), %rcx
cmpq %rax, (%r8)
jne 0x2e0a2e
movq 0x8(%r8), %rax
movq (%rax), %rax
cmpq $0x0, 0x68(%rax)
jne 0x2e0a97
leaq 0xf82a2(%rip), %rax     # 0x3d8cf1
jmp 0x2e0aab
movl 0x40(%rsi), %r8d
testl $0x1001, %r8d           # imm = 0x1001
je 0x2e0a97
movq (%rdi), %rax
movq 0x30(%rax), %rcx
testb $0x1, %r8b
jne 0x2e0a86
btl $0x1c, %ecx
jae 0x2e0a97
cmpq $0x0, 0x208(%rax)
jne 0x2e0a97
cmpl $0x0, 0xcc(%rax)
jne 0x2e0a97
jmp 0x2e0a48
andl $0x10000001, %ecx       # imm = 0x10000001
cmpl $0x1, %ecx
je 0x2e0a97
cmpb $0x0, 0x1e(%rdi)
je 0x2e0a48
xorl %eax, %eax
testl %edx, %edx
jne 0x2e0abd
cmpq $0x0, 0x18(%rsi)
je 0x2e0abd
leaq 0xf8263(%rip), %rax     # 0x3d8d0e
movq (%rsi), %rdx
movq %rax, %rsi
xorl %eax, %eax
callq 0x27b48d
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x38, %rsp
movl %ecx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x70(%rsi), %rax
testq %rax, %rax
je 0x2e0b14
movq 0x20(%rbx), %rcx
addq $0x18, %rcx
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rsi, %rbp
leaq 0x20(%rcx), %rdi
cmpq %rax, (%rcx)
movq %rdi, %rcx
jne 0x2e0aff
sarq $0x20, %rbp
jmp 0x2e0b1b
movq $-0x8000, %rbp          # imm = 0x8000
testq %rdx, %rdx
je 0x2e0b34
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
movq %rax, %r12
jmp 0x2e0b37
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2b1dc0
testq %rax, %rax
je 0x2e0b84
movq %rax, %r13
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x279928
movq %rax, 0x18(%r13)
movq 0x20(%rbx), %rax
shlq $0x5, %rbp
movq (%rax,%rbp), %rsi
movq %rbx, %rdi
callq 0x279928
movq %rax, 0x10(%r13)
subq $0x8, %rsp
xorl %eax, %eax
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
jmp 0x2e0b91
subq $0x8, %rsp
xorl %eax, %eax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq $0x20000                # imm = 0x20000
pushq %rax
callq 0x2b18d8
addq $0x20, %rsp
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movb $0xc, (%rdx)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rdx)
movl $0x0, 0x8(%rdx)
xorl %eax, %eax
movq %rax, 0x18(%rdx)
movq %rax, 0xc(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2af648
testq %r15, %r15
je 0x2e0bfb
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a62e6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa0(%rdi), %r14
testq %r14, %r14
cmoveq %rdi, %r14
movq %rsi, %rbx
movslq 0x120(%r14), %rax
movq 0x178(%r14), %rdi
testq %rax, %rax
jle 0x2e0e18
xorl %ecx, %ecx
cmpq %rbx, (%rdi,%rcx,8)
je 0x2e0e48
incq %rcx
cmpq %rcx, %rax
jne 0x2e0e0a
leal 0x8(,%rax,8), %eax
movslq %eax, %rsi
callq 0x272c63
testq %rax, %rax
je 0x2e0e50
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 0x278b1c
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebx
jne 0x2e1297
movq %rsi, %r14
movslq (%rsi), %rax
testq %rax, %rax
jle 0x2e1295
movq %rdi, %r15
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movq 0x10(%r14,%r13), %rsi
movq %r15, %rdi
callq 0x2c8ba9
testl %eax, %eax
jns 0x2e1297
addq $0x18, %r13
cmpq %r13, %r12
jne 0x2e127b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x18(%rsi), %rsi
movq %r14, %rdi
callq 0x279928
movq %rax, %r13
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2b1dc0
testq %rax, %rax
je 0x2e2c2c
movq %rax, %r15
movq 0x8(%r12), %rax
movq 0x28(%rax), %rax
movq %r13, 0x18(%r15)
movq 0x20(%r14), %rcx
cmpq 0x38(%rcx), %rax
je 0x2e2c01
movq %rax, 0x8(%r15)
movq 0x20(%r12), %rsi
testq %rsi, %rsi
je 0x2e2c3f
movq %r14, %rdi
xorl %edx, %edx
callq 0x2c30e3
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b2dbc
testq %r13, %r13
je 0x2e2c3c
movq %r14, %rdi
movq %r13, %rsi
callq 0x282904
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq 0x98(%rdi), %r13
testq %r13, %r13
je 0x2e3b97
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq (%rdi), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rbp
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movslq 0x10(%r13), %r14
movl 0x14(%r13), %r12d
movb 0x1f(%rbx), %al
testb %al, %al
je 0x2e3ae2
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xd4(%rbx,%rax,4), %r15d
jmp 0x2e3aed
movl 0x38(%rbx), %r15d
incl %r15d
movl %r15d, 0x38(%rbx)
leal 0x2(%r12), %edx
movl 0x90(%rbp), %ecx
addl $0x7, %ecx
movq %rbp, %rdi
movl $0x37, %esi
movl %r12d, %r8d
callq 0x2a83e1
movl 0x10(%r13), %edx
shlq $0x5, %r14
movq 0x10(%rsp), %rax
movq 0x18(%rax,%r14), %rax
movq 0x68(%rax), %rcx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x61, %r8d
callq 0x2bc82f
movq %rbp, %rdi
movl $0x5, %esi
leaq 0xf17b0(%rip), %rdx     # 0x3d52f0
callq 0x27b673
testq %rax, %rax
je 0x2e3b97
leal 0x1(%r12), %ecx
movl %ecx, 0x4(%rax)
movl %ecx, 0x20(%rax)
decl %r12d
movl %r12d, 0x34(%rax)
movl %r15d, 0x3c(%rax)
movl %r15d, 0x50(%rax)
movl %ecx, 0x54(%rax)
movw $0x8, 0x4a(%rax)
testl %r15d, %r15d
je 0x2e3b8a
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x2e3b8a
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %r15d, 0xd4(%rbx,%rax,4)
movq (%r13), %r13
testq %r13, %r13
jne 0x2e3ab4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x23aa(%rip), %rcx      # 0x2e5f75
movq %rcx, 0x8(%rsp)
movq %rsi, 0x28(%rsp)
testq %rdi, %rdi
je 0x2e3bf2
movq %rdi, %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2c0a8c
movzwl 0x24(%r14), %eax
jmp 0x2e3bf4
xorl %eax, %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_O3/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 0x2e5f9c
movswq 0x30(%rsi), %rcx
testq %rcx, %rcx
js 0x2e5f94
movq 0x28(%rdi), %rdx
movw $0x1, %ax
cmpl $0x0, (%rdx,%rcx,4)
jns 0x2e5f98
jmp 0x2e5f9c
movw $0x2, %ax
orw %ax, 0x24(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e6ebc
movq %rdi, %rax
movq (%rdi), %rdi
testb $0x4, 0x2c(%rdi)
jne 0x2e6ebc
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 0x2e6eb2
testb $-0x80, 0x40(%rcx)
jne 0x2e6eb2
cmpl $0x0, 0x54(%rcx)
jne 0x2e6eb2
cmpw $0x2, 0x46(%rcx)
jne 0x2e6eb2
leaq 0x98(%r15), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2e6ec9
cmpq %r14, 0x8(%rax)
jne 0x2e6e9f
movl 0x14(%rax), %ebx
jmp 0x2e6ebc
incl 0x30(%rax)
movl $0x20b, 0x18(%rax)      # imm = 0x20B
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %esi
callq 0x282a35
testq %rax, %rax
je 0x2e6ebc
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 0x2e6ebc