LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeAddFunctionCall
SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall(
  Parse *pParse,        /* Parsing context */
  int p1,               /* Constant argument mask */
  int p2,               /* First argument register */
  int p3,               /* Register into which results are written */
  int nArg,             /* Number of argument */
  const FuncDef *pFunc, /* The function to be invoked */
  int eCallCtx          /* Calling context */
){
  Vdbe *v = pParse->pVdbe;
  int nByte;
  int addr;
  sqlite3_context *pCtx;
  assert( v );
  nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
  pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
  if( pCtx==0 ){
    assert( pParse->db->mallocFailed );
    freeEphemeralFunction(pParse->db, (FuncDef*)pFunc);
    return 0;
  }
  pCtx->pOut = 0;
  pCtx->pFunc = (FuncDef*)pFunc;
  pCtx->pVdbe = 0;
  pCtx->isError = 0;
  pCtx->argc = nArg;
  pCtx->iOp = sqlite3VdbeCurrentAddr(v);
  addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function,
                           p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
  sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef);
  return addr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movl %r8d, %ebp
movl %ecx, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movl 0x50(%rsp), %r15d
movq (%rdi), %rdi
movq 0x10(%r14), %rbx
leal 0x30(,%rbp,8), %eax
movslq %eax, %rsi
callq 0x28c518
testq %rax, %rax
je 0x2c8663
movq %rax, %r13
xorl %esi, %esi
movq %rsi, (%rax)
movq %r12, 0x8(%rax)
movq %rsi, 0x18(%rax)
movl %esi, 0x24(%rax)
movb %bpl, 0x29(%rax)
movl 0x90(%rbx), %eax
movl %eax, 0x20(%r13)
cmpl $0x1, %r15d
adcl $0x3f, %esi
movq %rbx, %rdi
movl 0xc(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %r8d
callq 0x2b200c
movq %rbx, %rdi
movl %eax, %esi
movq %r13, %rdx
movl $0xfffffff0, %ecx       # imm = 0xFFFFFFF0
callq 0x285198
movslq 0x90(%rbx), %rax
testq %rax, %rax
jle 0x2c866b
andl $0x2e, %r15d
movq 0x88(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movw %r15w, -0x16(%rcx,%rax,8)
jmp 0x2c866b
testb $0x10, 0x4(%r12)
jne 0x2c867a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28c3e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprToRegister
SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
  while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
    if( ExprHasProperty(pExpr, EP_Unlikely) ){
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      assert( pExpr->x.pList->nExpr>0 );
      assert( pExpr->op==TK_FUNCTION );
      pExpr = pExpr->x.pList->a[0].pExpr;
    }else{
      assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
      pExpr = pExpr->pLeft;
    }
  }
  return pExpr;
}

// Assembly:
testq %rdi, %rdi
je 0x2c937f
movl 0x4(%rdi), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2c937f
btl $0x12, %eax
jb 0x2c9372
addq $0x10, %rdi
jmp 0x2c937a
movq 0x20(%rdi), %rdi
addq $0x8, %rdi
movq (%rdi), %rdi
jmp 0x2c9357
movb (%rdi), %al
movb %al, 0x2(%rdi)
movb $-0x53, (%rdi)
movl %esi, 0x2c(%rdi)
andb $-0x11, 0x5(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprCodeVector
static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){
  int iResult;
  int nResult = sqlite3ExprVectorSize(p);
  if( nResult==1 ){
    iResult = sqlite3ExprCodeTemp(pParse, p, piFreeable);
  }else{
    *piFreeable = 0;
    if( p->op==TK_SELECT ){
#if SQLITE_OMIT_SUBQUERY
      iResult = 0;
#else
      iResult = sqlite3CodeSubselect(pParse, p);
#endif
    }else{
      int i;
      iResult = pParse->nMem+1;
      pParse->nMem += nResult;
      for(i=0; i<nResult; i++){
        sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
      }
    }
  }
  return iResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rsi), %al
movl %eax, %ecx
cmpb $-0x53, %al
jne 0x2c93ab
movb 0x2(%rbx), %cl
movq %rbx, %rsi
cmpb $-0x52, %cl
je 0x2c93c7
movzbl %cl, %esi
movl $0x1, %ecx
cmpl $0x88, %esi
jne 0x2c93cd
movq 0x20(%rbx), %rsi
movq 0x20(%rsi), %rcx
movl (%rcx), %ecx
cmpl $0x1, %ecx
jne 0x2c93eb
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c7cda
movl $0x0, (%rdx)
cmpb $-0x78, %al
jne 0x2c940e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c8693
movl 0x38(%r14), %eax
leal 0x1(%rax), %ebp
addl %ecx, %eax
movl %eax, 0x38(%r14)
testl %ecx, %ecx
jle 0x2c944f
movl %ecx, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movl %ebp, %r15d
movq 0x20(%rbx), %rax
movq 0x8(%rax,%r13), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x2ccad9
incl %r15d
addq $0x18, %r13
cmpq %r13, %r12
jne 0x2c942f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCodeCopy
SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
  sqlite3 *db = pParse->db;
  pExpr = sqlite3ExprDup(db, pExpr, 0);
  if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
  sqlite3ExprDelete(db, pExpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %r14
movq (%rdi), %rbx
testq %rsi, %rsi
je 0x2c984b
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
movq %rax, %r15
jmp 0x2c984e
xorl %r15d, %r15d
cmpb $0x0, 0x61(%rbx)
jne 0x2c9861
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2c5f97
testq %r15, %r15
je 0x2c987b
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2afd54
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprVectorRegister
static int exprVectorRegister(
  Parse *pParse,                  /* Parse context */
  Expr *pVector,                  /* Vector to extract element from */
  int iField,                     /* Field to extract from pVector */
  int regSelect,                  /* First in array of registers */
  Expr **ppExpr,                  /* OUT: Expression element */
  int *pRegFree                   /* OUT: Temp register to free */
){
  u8 op = pVector->op;
  assert( op==TK_VECTOR || op==TK_REGISTER || op==TK_SELECT );
  if( op==TK_REGISTER ){
    *ppExpr = sqlite3VectorFieldSubexpr(pVector, iField);
    return pVector->iTable+iField;
  }
  if( op==TK_SELECT ){
    *ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
     return regSelect+iField;
  }
  *ppExpr = pVector->x.pList->a[iField].pExpr;
  return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movl %edx, %ebx
movq %rsi, %r15
movzbl (%rsi), %eax
cmpl $0x88, %eax
je 0x2c9fb2
cmpl $0xad, %eax
jne 0x2c9fd3
movq %r15, %rdi
movl %ebx, %esi
callq 0x2c9ff3
movq %rax, (%r14)
addl 0x2c(%r15), %ebx
jmp 0x2c9fcb
movq 0x20(%r15), %rax
movq 0x20(%rax), %rax
movslq %ebx, %rdx
leaq (%rdx,%rdx,2), %rdx
movq 0x8(%rax,%rdx,8), %rax
movq %rax, (%r14)
addl %ecx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x20(%r15), %rax
movslq %ebx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movq %rsi, (%r14)
movq %r9, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2c7cda
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VectorFieldSubexpr
SQLITE_PRIVATE Expr *sqlite3VectorFieldSubexpr(Expr *pVector, int i){
  assert( i<sqlite3ExprVectorSize(pVector) );
  if( sqlite3ExprIsVector(pVector) ){
    assert( pVector->op2==0 || pVector->op==TK_REGISTER );
    if( pVector->op==TK_SELECT || pVector->op2==TK_SELECT ){
      return pVector->x.pSelect->pEList->a[i].pExpr;
    }else{
      return pVector->x.pList->a[i].pExpr;
    }
  }
  return pVector;
}

// Assembly:
movq %rdi, %rax
movb (%rdi), %cl
movl %ecx, %edx
cmpb $-0x53, %cl
jne 0x2ca002
movb 0x2(%rax), %dl
movq %rax, %rdi
cmpb $-0x52, %dl
je 0x2ca019
movzbl %dl, %edx
cmpl $0x88, %edx
jne 0x2ca041
movq 0x20(%rax), %rdi
movq 0x20(%rdi), %rdx
cmpl $0x2, (%rdx)
jl 0x2ca041
cmpb $-0x78, %cl
je 0x2ca02d
cmpb $-0x78, 0x2(%rax)
jne 0x2ca031
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAffinity
SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
  int op;
  while( ExprHasProperty(pExpr, EP_Skip) ){
    assert( pExpr->op==TK_COLLATE || pExpr->op==TK_IF_NULL_ROW );
    pExpr = pExpr->pLeft;
    assert( pExpr!=0 );
  }
  op = pExpr->op;
  if( op==TK_SELECT ){
    assert( pExpr->flags&EP_xIsSelect );
    assert( pExpr->x.pSelect!=0 );
    assert( pExpr->x.pSelect->pEList!=0 );
    assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );
    return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
  }
  if( op==TK_REGISTER ) op = pExpr->op2;
#ifndef SQLITE_OMIT_CAST
  if( op==TK_CAST ){
    assert( !ExprHasProperty(pExpr, EP_IntValue) );
    return sqlite3AffinityType(pExpr->u.zToken, 0);
  }
#endif
  if( (op==TK_AGG_COLUMN || op==TK_COLUMN) && pExpr->y.pTab ){
    return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);
  }
  if( op==TK_SELECT_COLUMN ){
    assert( pExpr->pLeft->flags&EP_xIsSelect );
    return sqlite3ExprAffinity(
        pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr
    );
  }
  if( op==TK_VECTOR ){
    return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);
  }
  return pExpr->affExpr;
}

// Assembly:
testb $0x10, 0x5(%rdi)
je 0x2ca04e
movq 0x10(%rdi), %rdi
jmp 0x2ca042
movzbl (%rdi), %eax
cmpl $0xad, %eax
je 0x2ca06d
cmpl $0x88, %eax
jne 0x2ca070
movq 0x20(%rdi), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
jmp 0x2ca042
movb 0x2(%rdi), %al
cmpb $0x24, %al
je 0x2ca0bb
movl %eax, %ecx
andb $-0x3, %cl
cmpb $-0x5c, %cl
jne 0x2ca087
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
jne 0x2ca0ca
cmpb $-0x52, %al
je 0x2ca0b1
movzbl %al, %eax
cmpl $0xaf, %eax
jne 0x2ca0c6
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movswq 0x30(%rdi), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rdi
jmp 0x2ca042
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rdi
jmp 0x2ca042
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x2c7b4e
movb 0x1(%rdi), %al
retq
movswq 0x30(%rdi), %rax
testq %rax, %rax
js 0x2ca0e1
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movb 0x19(%rcx,%rax), %al
retq
movb $0x44, %al
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CompareAffinity
SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2){
  char aff1 = sqlite3ExprAffinity(pExpr);
  if( aff1>SQLITE_AFF_NONE && aff2>SQLITE_AFF_NONE ){
    /* Both sides of the comparison are columns. If one has numeric
    ** affinity, use that. Otherwise use no affinity.
    */
    if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
      return SQLITE_AFF_NUMERIC;
    }else{
      return SQLITE_AFF_BLOB;
    }
  }else{
    /* One side is a column, the other is not. Use the columns affinity. */
    assert( aff1<=SQLITE_AFF_NONE || aff2<=SQLITE_AFF_NONE );
    return (aff1<=SQLITE_AFF_NONE ? aff2 : aff1) | SQLITE_AFF_NONE;
  }
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x2ca042
cmpb $0x41, %al
setl %cl
cmpb $0x41, %bl
setl %dl
orb %cl, %dl
jne 0x2ca114
cmpb $0x43, %al
setae %al
addb %al, %al
orb $0x41, %al
cmpb $0x43, %bl
movzbl %al, %ecx
movl $0x43, %eax
cmovbl %ecx, %eax
jmp 0x2ca121
cmpb $0x41, %al
movzbl %bl, %ecx
movzbl %al, %eax
cmovll %ecx, %eax
orb $0x40, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: walkExpr
static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
  int rc;
  testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
  testcase( ExprHasProperty(pExpr, EP_Reduced) );
  while(1){
    rc = pWalker->xExprCallback(pWalker, pExpr);
    if( rc ) return rc & WRC_Abort;
    if( !ExprHasProperty(pExpr,(EP_TokenOnly|EP_Leaf)) ){
      assert( pExpr->x.pList==0 || pExpr->pRight==0 );
      if( pExpr->pLeft && walkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
      if( pExpr->pRight ){
        assert( !ExprHasProperty(pExpr, EP_WinFunc) );
        pExpr = pExpr->pRight;
        continue;
      }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        assert( !ExprHasProperty(pExpr, EP_WinFunc) );
        if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
      }else{
        if( pExpr->x.pList ){
          if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
        }
#ifndef SQLITE_OMIT_WINDOWFUNC
        if( ExprHasProperty(pExpr, EP_WinFunc) ){
          if( walkWindowList(pWalker, pExpr->y.pWin) ) return WRC_Abort;
        }
#endif
      }
    }
    break;
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, %r14
movq %rbx, %rdi
callq *0x8(%rbx)
testl %eax, %eax
jne 0x2ca29d
movzwl 0x5(%r14), %eax
testl $0x8040, %eax           # imm = 0x8040
jne 0x2ca2df
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x2ca24e
movq %rbx, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca2a2
movq 0x18(%r14), %rsi
testq %rsi, %rsi
jne 0x2ca21c
testb $0x8, 0x5(%r14)
movq 0x20(%r14), %r15
jne 0x2ca2a9
testq %r15, %r15
je 0x2ca2c1
movl (%r15), %ebp
testl %ebp, %ebp
setle %r12b
jle 0x2ca2c1
addq $0x8, %r15
incl %ebp
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2ca28c
movq %rbx, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca2b6
addq $0x18, %r15
decl %ebp
cmpl $0x2, %ebp
setl %r12b
jge 0x2ca278
jmp 0x2ca2c1
andl $0x2, %eax
jmp 0x2ca2e1
movl $0x2, %eax
jmp 0x2ca2e1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2ca2ea
jmp 0x2ca2d4
movl $0x2, %eax
testb $0x1, %r12b
je 0x2ca2e1
testb $0x1, 0x7(%r14)
je 0x2ca2df
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x2ca4a2
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x2ca2e1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WalkSelect
SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){
  int rc;
  if( p==0 ) return WRC_Continue;
  if( pWalker->xSelectCallback==0 ) return WRC_Continue;
  do{
    rc = pWalker->xSelectCallback(pWalker, p);
    if( rc ) return rc & WRC_Abort;
    if( sqlite3WalkSelectExpr(pWalker, p)
     || sqlite3WalkSelectFrom(pWalker, p)
    ){
      return WRC_Abort;
    }
    if( pWalker->xSelectCallback2 ){
      pWalker->xSelectCallback2(pWalker, p);
    }
    p = p->pPrior;
  }while( p!=0 );
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2ca43d
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x2ca43d
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%r15)
testl %eax, %eax
jne 0x2ca448
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x2ca44f
testl %eax, %eax
jne 0x2ca438
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x2ca34d
movq %r15, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca438
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x2ca44f
testl %eax, %eax
jne 0x2ca438
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x2ca37a
movq %r15, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca438
movq 0x48(%r14), %rsi
movq %r15, %rdi
callq 0x2ca44f
testl %eax, %eax
jne 0x2ca438
movq 0x60(%r14), %rsi
testq %rsi, %rsi
je 0x2ca3a7
movq %r15, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca438
movq (%r15), %rax
testq %rax, %rax
je 0x2ca3c8
cmpb $0x2, 0x11c(%rax)
jb 0x2ca3c8
movq 0x78(%r14), %rsi
movq %r15, %rdi
callq 0x2ca4a2
testl %eax, %eax
jne 0x2ca438
movq 0x28(%r14), %r12
testq %r12, %r12
je 0x2ca418
movl (%r12), %ebp
testl %ebp, %ebp
jle 0x2ca418
addq $0x30, %r12
incl %ebp
movq (%r12), %rsi
testq %rsi, %rsi
je 0x2ca3f4
movq %r15, %rdi
callq 0x2ca2ea
testl %eax, %eax
jne 0x2ca438
testb $0x4, 0x15(%r12)
je 0x2ca40d
movq 0x38(%r12), %rsi
movq %r15, %rdi
callq 0x2ca44f
testl %eax, %eax
jne 0x2ca438
addq $0x70, %r12
decl %ebp
cmpl $0x1, %ebp
jg 0x2ca3df
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x2ca429
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x2ca30e
jmp 0x2ca43d
movl $0x2, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andl $0x2, %eax
movl %eax, %ebx
jmp 0x2ca43d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: walkWindowList
static int walkWindowList(Walker *pWalker, Window *pList){
  Window *pWin;
  for(pWin=pList; pWin; pWin=pWin->pNextWin){
    int rc;
    rc = sqlite3WalkExprList(pWalker, pWin->pOrderBy);
    if( rc ) return WRC_Abort;
    rc = sqlite3WalkExprList(pWalker, pWin->pPartition);
    if( rc ) return WRC_Abort;
    rc = sqlite3WalkExpr(pWalker, pWin->pFilter);
    if( rc ) return WRC_Abort;

    /* The next two are purely for calls to sqlite3RenameExprUnmap()
    ** within sqlite3WindowOffsetExpr().  Because of constraints imposed
    ** by sqlite3WindowOffsetExpr(), they can never fail.  The results do
    ** not matter anyhow. */
    rc = sqlite3WalkExpr(pWalker, pWin->pStart);
    if( NEVER(rc) ) return WRC_Abort;
    rc = sqlite3WalkExpr(pWalker, pWin->pEnd);
    if( NEVER(rc) ) return WRC_Abort;
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2ca51e
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %ebp
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2ca44f
testl %eax, %eax
jne 0x2ca520
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x2ca44f
testl %eax, %eax
jne 0x2ca520
movq 0x48(%rbx), %rsi
testq %rsi, %rsi
je 0x2ca4eb
movq %r14, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca520
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x2ca500
movq %r14, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca520
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x2ca515
movq %r14, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2ca520
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x2ca4b6
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowCompare
SQLITE_PRIVATE int sqlite3WindowCompare(Parse *pParse, Window *p1, Window *p2, int bFilter){
  int res;
  if( NEVER(p1==0) || NEVER(p2==0) ) return 1;
  if( p1->eFrmType!=p2->eFrmType ) return 1;
  if( p1->eStart!=p2->eStart ) return 1;
  if( p1->eEnd!=p2->eEnd ) return 1;
  if( p1->eExclude!=p2->eExclude ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
  if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
  if( (res = sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1)) ){
    return res;
  }
  if( (res = sqlite3ExprListCompare(p1->pOrderBy, p2->pOrderBy, -1)) ){
    return res;
  }
  if( bFilter ){
    if( (res = sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1)) ){
      return res;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0x1, %ebx
jne 0x2ca99b
movq %rdx, %r15
movq %rsi, %r12
movb 0x20(%rsi), %al
cmpb 0x20(%rdx), %al
jne 0x2ca99b
movb 0x21(%r12), %al
cmpb 0x21(%r15), %al
jne 0x2ca99b
movb 0x22(%r12), %al
cmpb 0x22(%r15), %al
jne 0x2ca99b
movb 0x24(%r12), %al
cmpb 0x24(%r15), %al
jne 0x2ca99b
movq %rdi, %r14
movq 0x28(%r12), %rsi
movq 0x28(%r15), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2ca527
testl %eax, %eax
jne 0x2ca99b
movq 0x30(%r12), %rsi
movq 0x30(%r15), %rdx
movq %r14, %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2ca527
testl %eax, %eax
jne 0x2ca99b
movq 0x10(%r12), %rdi
movq 0x10(%r15), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2ca9c8
testl %eax, %eax
jne 0x2ca999
movq 0x18(%r12), %rdi
movq 0x18(%r15), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2ca9c8
testl %eax, %eax
je 0x2ca9a6
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x2ca9c4
movq 0x48(%r12), %rsi
movq 0x48(%r15), %rdx
movq %r14, %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2ca527
testl %eax, %eax
jne 0x2ca999
xorl %ebx, %ebx
jmp 0x2ca99b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprListCompare
SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){
  int i;
  if( pA==0 && pB==0 ) return 0;
  if( pA==0 || pB==0 ) return 1;
  if( pA->nExpr!=pB->nExpr ) return 1;
  for(i=0; i<pA->nExpr; i++){
    int res;
    Expr *pExprA = pA->a[i].pExpr;
    Expr *pExprB = pB->a[i].pExpr;
    if( pA->a[i].sortFlags!=pB->a[i].sortFlags ) return 1;
    if( (res = sqlite3ExprCompare(0, pExprA, pExprB, iTab)) ) return res;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
movq %rdi, %rax
orq %rsi, %rax
je 0x2caa59
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movl $0x1, %ebp
jne 0x2caa59
movl (%r15), %eax
cmpl (%r14), %eax
jne 0x2caa59
cmpl $0x0, (%r15)
movl $0x0, %ebp
jle 0x2caa59
movl %edx, %ebx
movl $0x18, %r12d
xorl %r13d, %r13d
movb (%r15,%r12), %al
cmpb (%r14,%r12), %al
jne 0x2caa3d
movq -0x10(%r14,%r12), %rdx
movq -0x10(%r15,%r12), %rsi
xorl %edi, %edi
movl %ebx, %ecx
callq 0x2ca527
testl %eax, %eax
sete %cl
cmovnel %eax, %ebp
jmp 0x2caa44
movl $0x1, %ebp
xorl %ecx, %ecx
testb %cl, %cl
je 0x2caa59
incq %r13
movslq (%r15), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x2caa16
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeGetBoundValue
SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){
  assert( iVar>0 );
  if( v ){
    Mem *pMem = &v->aVar[iVar-1];
    assert( (v->db->flags & SQLITE_EnableQPSG)==0 );
    if( 0==(pMem->flags & MEM_Null) ){
      sqlite3_value *pRet = sqlite3ValueNew(v->db);
      if( pRet ){
        sqlite3VdbeMemCopy((Mem *)pRet, pMem);
        sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8);
      }
      return pRet;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2caac9
movq 0x80(%rdi), %r15
movslq %esi, %rax
imulq $0x38, %rax, %r12
movzwl -0x30(%r15,%r12), %ebp
testb $0x1, %bpl
jne 0x2caac3
movq (%rdi), %r14
movl $0x38, %esi
movq %r14, %rdi
callq 0x283569
movq %rax, %rbx
testq %rax, %rax
je 0x2caac3
leaq (%r15,%r12), %rsi
addq $-0x38, %rsi
movw $0x1, 0x8(%rbx)
movq %r14, 0x28(%rbx)
movq %rbx, %rdi
callq 0x282324
testb $0x1, %bpl
je 0x2caacb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprImpliesExpr
SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Parse *pParse, Expr *pE1, Expr *pE2, int iTab){
  if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){
    return 1;
  }
  if( pE2->op==TK_OR
   && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab)
             || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) )
  ){
    return 1;
  }
  if( pE2->op==TK_NOTNULL
   && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0)
  ){
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x2ca527
movl $0x1, %ebx
testl %eax, %eax
je 0x2cab4d
cmpb $0x2b, (%r12)
jne 0x2cab2b
movq 0x10(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x2caad7
testl %eax, %eax
jne 0x2cab4d
movq 0x18(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x2caad7
testl %eax, %eax
jne 0x2cab4d
cmpb $0x33, (%r12)
jne 0x2cab4b
movq 0x10(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x2cabfe
testl %eax, %eax
jne 0x2cab4d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprImpliesNonNullRow
SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){
  Walker w;
  p = sqlite3ExprSkipCollateAndLikely(p);
  if( p==0 ) return 0;
  if( p->op==TK_NOTNULL ){
    p = p->pLeft;
  }else{
    while( p->op==TK_AND ){
      if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1;
      p = p->pRight;
    }
  }
  w.xExprCallback = impliesNotNullRow;
  w.xSelectCallback = 0;
  w.xSelectCallback2 = 0;
  w.eCode = 0;
  w.u.iCur = iTab;
  sqlite3WalkExpr(&w, p);
  return w.eCode;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2cab8e
movl 0x4(%rbx), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2cab8e
btl $0x12, %eax
jb 0x2cab7e
addq $0x10, %rbx
jmp 0x2cab86
movq 0x20(%rbx), %rbx
addq $0x8, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2cab68
testq %rbx, %rbx
je 0x2cabee
cmpb $0x33, (%rbx)
jne 0x2cabd4
movq 0x10(%rbx), %rbx
leaq 0x1c1(%rip), %rax       # 0x2cad64
movq %rax, 0x10(%rsp)
movw $0x0, 0x2c(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movl %ebp, 0x30(%rsp)
testq %rbx, %rbx
je 0x2cabcd
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2ca211
movzwl 0x2c(%rsp), %eax
jmp 0x2cabf0
cmpb $0x2c, (%rbx)
jne 0x2cab9c
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x2cab58
testl %eax, %eax
jne 0x2cabf7
movq 0x18(%rbx), %rbx
jmp 0x2cabd4
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %eax
jmp 0x2cabf0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeExplain
SQLITE_PRIVATE void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
#ifndef SQLITE_DEBUG
  /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.
  ** But omit them (for performance) during production builds */
  if( pParse->explain==2 )
#endif
  {
    char *zMsg;
    Vdbe *v;
    va_list ap;
    int iThis;
    va_start(ap, zFmt);
    zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap);
    va_end(ap);
    v = pParse->pVdbe;
    iThis = v->nOp;
    sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
                      zMsg, P4_DYNAMIC);
    sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetOp(v,-1)->p4.z);
    if( bPush){
      pParse->addrExplain = iThis;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2caead
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
cmpb $0x2, 0x11b(%rdi)
jne 0x2caf3e
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000018, %rcx     # imm = 0x3000000018
movq %rcx, (%rax)
movq (%rdi), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x28e62e
movq %rax, %r15
movq 0x10(%rbx), %r12
movl 0x90(%r12), %r14d
movl 0x128(%rbx), %ecx
movq %r12, %rdi
movl $0xae, %esi
movl %r14d, %edx
xorl %r8d, %r8d
callq 0x2b200c
movq %r12, %rdi
movl %eax, %esi
movq %r15, %rdx
movl $0xfffffff9, %ecx       # imm = 0xFFFFFFF9
callq 0x285198
testb %bpl, %bpl
je 0x2caf3e
movl %r14d, 0x128(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCheckIN
SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn){
  int nVector = sqlite3ExprVectorSize(pIn->pLeft);
  if( (pIn->flags & EP_xIsSelect) ){
    if( nVector!=pIn->x.pSelect->pEList->nExpr ){
      sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector);
      return 1;
    }
  }else if( nVector!=1 ){
    sqlite3VectorErrorMsg(pParse, pIn->pLeft);
    return 1;
  }
  return 0;
}

// Assembly:
movq %rsi, %rax
movq 0x10(%rsi), %rsi
movb (%rsi), %cl
cmpb $-0x53, %cl
jne 0x2caf5f
movb 0x2(%rsi), %cl
movq %rsi, %rdx
cmpb $-0x52, %cl
je 0x2caf7b
movzbl %cl, %edx
movl $0x1, %ecx
cmpl $0x88, %edx
jne 0x2caf81
movq 0x20(%rsi), %rdx
movq 0x20(%rdx), %rcx
movl (%rcx), %ecx
pushq %rbx
testb $0x8, 0x5(%rax)
jne 0x2caf99
cmpl $0x1, %ecx
je 0x2cafa7
callq 0x2cbde0
movl $0x1, %ebx
jmp 0x2cafc4
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movl (%rax), %edx
cmpl %edx, %ecx
jne 0x2cafab
xorl %ebx, %ebx
jmp 0x2cafc4
movl $0x1, %ebx
cmpl $0x0, 0x30(%rdi)
jne 0x2cafc4
leaq 0x115dd5(%rip), %rsi    # 0x3e0d92
xorl %eax, %eax
callq 0x284eb8
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprINAffinity
static char *exprINAffinity(Parse *pParse, Expr *pExpr){
  Expr *pLeft = pExpr->pLeft;
  int nVal = sqlite3ExprVectorSize(pLeft);
  Select *pSelect = (pExpr->flags & EP_xIsSelect) ? pExpr->x.pSelect : 0;
  char *zRet;

  assert( pExpr->op==TK_IN );
  zRet = sqlite3DbMallocRaw(pParse->db, nVal+1);
  if( zRet ){
    int i;
    for(i=0; i<nVal; i++){
      Expr *pA = sqlite3VectorFieldSubexpr(pLeft, i);
      char a = sqlite3ExprAffinity(pA);
      if( pSelect ){
        zRet[i] = sqlite3CompareAffinity(pSelect->pEList->a[i].pExpr, a);
      }else{
        zRet[i] = a;
      }
    }
    zRet[nVal] = '\0';
  }
  return zRet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rbx
movb (%rbx), %al
cmpb $-0x53, %al
jne 0x2cafe0
movb 0x2(%rbx), %al
movq %rbx, %rcx
cmpb $-0x52, %al
je 0x2caffb
movzbl %al, %eax
movl $0x1, %r15d
cmpl $0x88, %eax
jne 0x2cb002
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rax
movl (%rax), %r15d
testb $0x8, 0x5(%rsi)
jne 0x2cb00d
xorl %r13d, %r13d
jmp 0x2cb011
movq 0x20(%rsi), %r13
movq (%rdi), %rdi
leal 0x1(%r15), %eax
movslq %eax, %rsi
testq %rdi, %rdi
je 0x2cb027
callq 0x28c518
jmp 0x2cb02f
movq %rsi, %rdi
callq 0x27c381
movq %rax, %r14
testq %rax, %rax
je 0x2cb08d
movq %r15, (%rsp)
testl %r15d, %r15d
jle 0x2cb084
movl (%rsp), %ebp
movl $0x8, %r12d
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2c9ff3
movq %rax, %rdi
callq 0x2ca042
testq %r13, %r13
je 0x2cb074
movq 0x20(%r13), %rcx
movq (%rcx,%r12), %rdi
movsbl %al, %esi
callq 0x2ca0e4
movb %al, (%r14,%r15)
incq %r15
addq $0x18, %r12
cmpq %r15, %rbp
jne 0x2cb04c
movslq (%rsp), %rax
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCanBeNull
SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
  u8 op;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
    p = p->pLeft;
  }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER:
    case TK_STRING:
    case TK_FLOAT:
    case TK_BLOB:
      return 0;
    case TK_COLUMN:
      return ExprHasProperty(p, EP_CanBeNull) ||
             p->y.pTab==0 ||  /* Reference to column of index on expression */
             (p->iColumn>=0
              && ALWAYS(p->y.pTab->aCol!=0) /* Defense against OOM problems */
              && p->y.pTab->aCol[p->iColumn].notNull==0);
    default:
      return 1;
  }
}

// Assembly:
movb (%rdi), %al
movzbl %al, %ecx
leal -0xaa(%rcx), %edx
cmpl $0x2, %edx
jae 0x2cbd77
movq 0x10(%rdi), %rdi
jmp 0x2cbd61
cmpl $0xad, %ecx
jne 0x2cbd82
movb 0x2(%rdi), %al
movzbl %al, %eax
leal -0x96(%rax), %ecx
cmpl $0x3, %ecx
jb 0x2cbdd7
cmpl $0x73, %eax
je 0x2cbdd7
cmpl $0xa4, %eax
jne 0x2cbdda
movl $0x1, %eax
testb $0x10, 0x6(%rdi)
jne 0x2cbddf
movq 0x40(%rdi), %rdx
testq %rdx, %rdx
je 0x2cbddf
movswq 0x30(%rdi), %rcx
testq %rcx, %rcx
js 0x2cbdd7
movq 0x8(%rdx), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0x2cbddf
shlq $0x5, %rcx
xorl %eax, %eax
cmpb $0x0, 0x18(%rdx,%rcx)
sete %al
retq
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VectorErrorMsg
SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
#ifndef SQLITE_OMIT_SUBQUERY
  if( pExpr->flags & EP_xIsSelect ){
    sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
  }else
#endif
  {
    sqlite3ErrorMsg(pParse, "row value misused");
  }
}

// Assembly:
testb $0x8, 0x5(%rsi)
jne 0x2cbdf4
leaq 0x114f31(%rip), %rsi    # 0x3e0d1e
xorl %eax, %eax
jmp 0x284eb8
cmpl $0x0, 0x30(%rdi)
je 0x2cbdfb
retq
movq 0x20(%rsi), %rax
movq 0x20(%rax), %rax
movl (%rax), %edx
leaq 0x114f86(%rip), %rsi    # 0x3e0d92
movl $0x1, %ecx
xorl %eax, %eax
jmp 0x284eb8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CodeVerifySchema
SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);

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

// Assembly:
movq %rdi, %rax
movq 0xa0(%rdi), %rdi
testq %rdi, %rdi
cmoveq %rax, %rdi
movl %esi, %ecx
movl 0x74(%rdi), %eax
movl $0x1, %edx
shll %cl, %edx
btl %esi, %eax
jb 0x2cbe48
orl %edx, %eax
movl %eax, 0x74(%rdi)
cmpl $0x1, %ecx
je 0x28e6f9
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SetHasNullFlag
static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){
  int addr1;
  sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull);
  addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
  sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull);
  sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
  VdbeComment((v, "first_entry_in(%d)", iCur));
  sqlite3VdbeJumpHere(v, addr1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x45, %esi
xorl %edx, %edx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl $0x25, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl %eax, %ebp
movq %rbx, %rdi
movl $0x59, %esi
movl %r15d, %edx
xorl %ecx, %ecx
movl %r14d, %r8d
callq 0x2b200c
movslq 0x90(%rbx), %rax
testq %rax, %rax
jle 0x2cbeb5
movq 0x88(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
movw $0x80, -0x16(%rcx,%rdx,8)
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2cbec7
leaq 0x1fdfc3(%rip), %rcx    # 0x4c9e88
jmp 0x2cbee1
leal -0x1(%rax), %ecx
testl %ebp, %ebp
cmovnsl %ebp, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rbx), %rcx
movl %eax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeChangeToNoop
SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
  VdbeOp *pOp;
  if( p->db->mallocFailed ) return 0;
  assert( addr>=0 && addr<p->nOp );
  pOp = &p->aOp[addr];
  freeP4(p->db, pOp->p4type, pOp->p4.p);
  pOp->p4type = P4_NOTUSED;
  pOp->p4.z = 0;
  pOp->opcode = OP_Noop;
  return 1;
}

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2cbefc
retq
pushq %r14
pushq %rbx
pushq %rax
movq 0x88(%rax), %rbx
movslq %esi, %rax
leaq (%rax,%rax,2), %r14
movsbl 0x1(%rbx,%r14,8), %esi
movq 0x10(%rbx,%r14,8), %rdx
callq 0x29991d
movq $0x0, 0x10(%rbx,%r14,8)
movw $0xad, (%rbx,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resizeResolveLabel
static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
  int nNewSize = 10 - p->nLabel;
  p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
                     nNewSize*sizeof(p->aLabel[0]));
  if( p->aLabel==0 ){
    p->nLabelAlloc = 0;
  }else{
#ifdef SQLITE_DEBUG
    int i;
    for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1;
#endif
    p->nLabelAlloc = nNewSize;
    p->aLabel[j] = v->nOp;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movslq 0x44(%rdi), %rax
movl $0xa, %r12d
subq %rax, %r12
movq (%rdi), %rdi
movq 0x50(%r15), %rsi
leaq (,%r12,4), %rdx
callq 0x29b6a6
movq %rax, 0x50(%r15)
testq %rax, %rax
je 0x2cbf83
movl %r12d, 0x48(%r15)
movl 0x90(%r14), %ecx
movslq %ebx, %rdx
movl %ecx, (%rax,%rdx,4)
jmp 0x2cbf8b
movl $0x0, 0x48(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: dupedExprNodeSize
static int dupedExprNodeSize(Expr *p, int flags){
  int nByte = dupedExprStructSize(p, flags) & 0xfff;
  if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
    nByte += sqlite3Strlen30NN(p->u.zToken)+1;
  }
  return ROUND8(nByte);
}

// Assembly:
pushq %rbx
movl $0x48, %ebx
testl %esi, %esi
je 0x2cc6c6
cmpb $-0x51, (%rdi)
je 0x2cc6c6
testb $0x1, 0x7(%rdi)
jne 0x2cc6c6
movl $0x2c, %ebx
cmpq $0x0, 0x10(%rdi)
jne 0x2cc6c6
cmpq $0x0, 0x20(%rdi)
movl $0x10, %eax
movl $0x2c, %ebx
cmovel %eax, %ebx
testb $0x4, 0x5(%rdi)
jne 0x2cc6e3
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2cc6e3
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
addl %eax, %ebx
incl %ebx
addl $0x7, %ebx
andl $-0x8, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowDup
SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p){
  Window *pNew = 0;
  if( ALWAYS(p) ){
    pNew = sqlite3DbMallocZero(db, sizeof(Window));
    if( pNew ){
      pNew->zName = sqlite3DbStrDup(db, p->zName);
      pNew->zBase = sqlite3DbStrDup(db, p->zBase);
      pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0);
      pNew->pFunc = p->pFunc;
      pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0);
      pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0);
      pNew->eFrmType = p->eFrmType;
      pNew->eEnd = p->eEnd;
      pNew->eStart = p->eStart;
      pNew->eExclude = p->eExclude;
      pNew->regResult = p->regResult;
      pNew->regAccum = p->regAccum;
      pNew->iArgCol = p->iArgCol;
      pNew->iEphCsr = p->iEphCsr;
      pNew->bExprArgs = p->bExprArgs;
      pNew->pStart = sqlite3ExprDup(db, p->pStart, 0);
      pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0);
      pNew->pOwner = pOwner;
      pNew->bImplicitFrame = p->bImplicitFrame;
    }
  }
  return pNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x2cc74b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x90, %esi
callq 0x283569
testq %rax, %rax
je 0x2cc74b
movq %rax, %rbx
movq (%r14), %rsi
movq %r12, %rdi
callq 0x283365
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x283365
movq %rax, 0x8(%rbx)
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x2cc752
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
jmp 0x2cc754
xorl %ebx, %ebx
jmp 0x2cc810
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x50(%rbx)
movq 0x10(%r14), %rsi
xorl %r13d, %r13d
movq %r12, %rdi
xorl %edx, %edx
callq 0x2cc525
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x2cc525
movq %rax, 0x18(%rbx)
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movb 0x22(%r14), %al
movb %al, 0x22(%rbx)
movb 0x21(%r14), %al
movb %al, 0x21(%rbx)
movb 0x24(%r14), %al
movb %al, 0x24(%rbx)
movl 0x60(%r14), %eax
movl %eax, 0x60(%rbx)
movl 0x5c(%r14), %eax
movl %eax, 0x5c(%rbx)
movl 0x7c(%r14), %eax
movl %eax, 0x7c(%rbx)
movl 0x58(%r14), %eax
movl %eax, 0x58(%rbx)
movb 0x8c(%r14), %al
movb %al, 0x8c(%rbx)
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x2cc7e4
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
movq %rax, %r13
movq %r13, 0x28(%rbx)
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x2cc7ff
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
jmp 0x2cc801
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %r15, 0x70(%rbx)
movb 0x23(%r14), %al
movb %al, 0x23(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IdListDup
SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
  IdList *pNew;
  int i;
  assert( db!=0 );
  if( p==0 ) return 0;
  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
  if( pNew==0 ) return 0;
  pNew->nId = p->nId;
  pNew->a = sqlite3DbMallocRawNN(db, p->nId*sizeof(p->a[0]) );
  if( pNew->a==0 ){
    sqlite3DbFreeNN(db, pNew);
    return 0;
  }
  /* Note that because the size of the allocation for p->a[] is not
  ** necessarily a power of two, sqlite3IdListAppend() may not be called
  ** on the duplicate created by this function. */
  for(i=0; i<p->nId; i++){
    struct IdList_item *pNewItem = &pNew->a[i];
    struct IdList_item *pOldItem = &p->a[i];
    pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
    pNewItem->idx = pOldItem->idx;
  }
  return pNew;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2cca4c
movq %rsi, %r15
movq %rdi, %r14
movl $0x10, %esi
callq 0x28c518
testq %rax, %rax
je 0x2cca4c
movq %rax, %rbx
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movslq 0x8(%r15), %rsi
shlq $0x4, %rsi
movq %r14, %rdi
callq 0x28c518
movq %rax, (%rbx)
testq %rax, %rax
je 0x2cca41
cmpl $0x0, 0x8(%r15)
jle 0x2cca4e
movl $0x8, %r12d
xorl %r13d, %r13d
movq %r14, (%rsp)
movq (%rbx), %rbp
movq (%r15), %r14
movq -0x8(%r14,%r12), %rsi
movq (%rsp), %rdi
callq 0x283365
movq %rax, -0x8(%rbp,%r12)
movl (%r14,%r12), %eax
movl %eax, (%rbp,%r12)
incq %r13
movslq 0x8(%r15), %rax
addq $0x10, %r12
cmpq %rax, %r13
jl 0x2cca0d
jmp 0x2cca4e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28c3e7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: gatherSelectWindowsCallback
static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
    Select *pSelect = pWalker->u.pSelect;
    Window *pWin = pExpr->y.pWin;
    assert( pWin );
    assert( IsWindowFunc(pExpr) );
    assert( pWin->ppThis==0 );
    sqlite3WindowLink(pSelect, pWin);
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x57, (%rsi)
jne 0x2cca7d
testb $0x1, 0x7(%rsi)
je 0x2cca7d
pushq %rax
movq 0x28(%rdi), %rdi
movq 0x40(%rsi), %rsi
callq 0x2cca8a
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowLink
SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){
  if( pSel!=0
   && (0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0))
  ){
    pWin->pNextWin = pSel->pWin;
    if( pSel->pWin ){
      pSel->pWin->ppThis = &pWin->pNextWin;
    }
    pSel->pWin = pWin;
    pWin->ppThis = &pSel->pWin;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2ccad8
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rsi
testq %rsi, %rsi
je 0x2ccab2
xorl %edi, %edi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2ca8e1
testl %eax, %eax
jne 0x2ccad1
addq $0x70, %r14
movq (%r14), %rax
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x2ccaca
leaq 0x40(%rbx), %rcx
movq %rcx, 0x38(%rax)
movq %rbx, (%r14)
movq %r14, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCodeFactorable
SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
  if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
    sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
  }else{
    sqlite3ExprCodeCopy(pParse, pExpr, target);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0x23(%rdi)
je 0x2ccb3e
movw $0x2, 0x24(%rsp)
leaq -0x29db(%rip), %rax     # 0x2ca123
movq %rax, 0x8(%rsp)
leaq -0x2905(%rip), %rax     # 0x2ca205
movq %rax, 0x10(%rsp)
movl $0x0, 0x28(%rsp)
testq %r14, %r14
je 0x2ccb27
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2ca211
cmpw $0x0, 0x24(%rsp)
je 0x2ccb3e
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2c7eee
jmp 0x2ccb4b
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2c9826
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprSimplifiedAndOr
SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
  assert( pExpr!=0 );
  if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
    Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
    Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
    if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){
      pExpr = pExpr->op==TK_AND ? pRight : pLeft;
    }else if( ExprAlwaysTrue(pRight) || ExprAlwaysFalse(pLeft) ){
      pExpr = pExpr->op==TK_AND ? pLeft : pRight;
    }
  }
  return pExpr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %r15b
leal -0x2b(%r15), %eax
cmpb $0x1, %al
ja 0x2ccbaf
movq 0x18(%rbx), %rdi
callq 0x2ccb55
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x2ccb55
movl 0x4(%rax), %ecx
movl %ecx, %edx
andl $0x10000001, %edx       # imm = 0x10000001
cmpl $0x10000000, %edx       # imm = 0x10000000
je 0x2ccba4
movl 0x4(%r14), %edx
movl %edx, %esi
andl $0x20000001, %esi       # imm = 0x20000001
cmpl $0x20000000, %esi       # imm = 0x20000000
jne 0x2ccbb8
cmpb $0x2c, %r15b
cmoveq %r14, %rax
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
andl $0x20000001, %ecx       # imm = 0x20000001
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x2ccbd4
andl $0x10000001, %edx       # imm = 0x10000001
cmpl $0x10000000, %edx       # imm = 0x10000000
jne 0x2ccbaf
cmpb $0x2c, %r15b
cmoveq %rax, %r14
movq %r14, %rbx
jmp 0x2ccbaf