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: codeCompare
static int codeCompare(
  Parse *pParse,    /* The parsing (and code generating) context */
  Expr *pLeft,      /* The left operand */
  Expr *pRight,     /* The right operand */
  int opcode,       /* The comparison opcode */
  int in1, int in2, /* Register holding operands */
  int dest,         /* Jump here if true.  */
  int jumpIfNull,   /* If true, jump if either operand is NULL */
  int isCommuted    /* The comparison has been commuted */
){
  int p5;
  int addr;
  CollSeq *p4;

  if( pParse->nErr ) return 0;
  if( isCommuted ){
    p4 = sqlite3BinaryCompareCollSeq(pParse, pRight, pLeft);
  }else{
    p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
  }
  p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
  addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
                           (void*)p4, P4_COLLSEQ);
  sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
  return addr;
}

// Assembly:
cmpl $0x0, 0x30(%rdi)
je 0x2be6ed
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
cmpl $0x0, 0x50(%rsp)
je 0x2be719
movq %r12, %rsi
movq %r13, %rdx
jmp 0x2be71f
movq %r13, %rsi
movq %r12, %rdx
callq 0x2a9634
movq %rax, (%rsp)
movq %r12, %rdi
callq 0x2c08a4
movsbl %al, %esi
movq %r13, %rdi
callq 0x2c0948
movl %eax, %r12d
movq 0x10(%rbx), %r13
movq %r13, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl 0x40(%rsp), %ecx
movl %ebp, %r8d
callq 0x2a83e1
movq %r13, %rdi
movl %eax, %esi
movq (%rsp), %rdx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x27b778
movq 0x10(%rbx), %rax
movslq 0x90(%rax), %rcx
testq %rcx, %rcx
jle 0x2be795
movl 0x48(%rsp), %edx
orb %dl, %r12b
movzbl %r12b, %edx
movq 0x88(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movw %dx, -0x16(%rax,%rcx,8)
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: sqlite3GetTempRange
SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){
  int i, n;
  if( nReg==1 ) return sqlite3GetTempReg(pParse);
  i = pParse->iRangeReg;
  n = pParse->nRangeReg;
  if( nReg<=n ){
    pParse->iRangeReg += nReg;
    pParse->nRangeReg -= nReg;
  }else{
    i = pParse->nMem+1;
    pParse->nMem += nReg;
  }
  return i;
}

// Assembly:
cmpl $0x1, %esi
jne 0x2beb31
movb 0x1f(%rdi), %al
testb %al, %al
je 0x2beb50
decb %al
movb %al, 0x1f(%rdi)
movzbl %al, %eax
movl 0xd4(%rdi,%rax,4), %eax
retq
movl 0x28(%rdi), %ecx
subl %esi, %ecx
jge 0x2beb44
movl 0x38(%rdi), %ecx
leal 0x1(%rcx), %eax
addl %ecx, %esi
movl %esi, 0x38(%rdi)
retq
movl 0x2c(%rdi), %eax
addl %eax, %esi
movl %esi, 0x2c(%rdi)
movl %ecx, 0x28(%rdi)
retq
movl 0x38(%rdi), %eax
incl %eax
movl %eax, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x282a35
testq %rax, %rax
je 0x2bef09
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 0x2a83e1
movq %rbx, %rdi
movl %eax, %esi
movq %r13, %rdx
movl $0xfffffff0, %ecx       # imm = 0xFFFFFFF0
callq 0x27b778
movslq 0x90(%rbx), %rax
testq %rax, %rax
jle 0x2bef11
andl $0x2e, %r15d
movq 0x88(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movw %r15w, -0x16(%rcx,%rax,8)
jmp 0x2bef11
testb $0x10, 0x4(%r12)
jne 0x2bef20
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 0x282904
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x4(%rdi), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2bfc0c
btl $0x12, %eax
jb 0x2bfbff
addq $0x10, %rdi
jmp 0x2bfc07
movq 0x20(%rdi), %rdi
addq $0x8, %rdi
movq (%rdi), %rdi
jmp 0x2bfbe9
movb (%rdi), %cl
movb %cl, 0x2(%rdi)
movb $-0x53, (%rdi)
movl %esi, 0x2c(%rdi)
andl $0xffffefff, %eax       # imm = 0xFFFFEFFF
movl %eax, 0x4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bfc3c
movb 0x2(%rbx), %cl
movq %rbx, %rsi
cmpb $-0x52, %cl
je 0x2bfc53
movzbl %cl, %ecx
cmpl $0x88, %ecx
jne 0x2bfc5f
movq 0x20(%rbx), %rsi
movq 0x20(%rsi), %rcx
movl (%rcx), %ecx
cmpq $0x1, %rcx
jne 0x2bfc78
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2be5d4
movl $0x0, (%rdx)
cmpb $-0x78, %al
jne 0x2bfc9b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2bef39
movl 0x38(%r14), %eax
leal 0x1(%rax), %ebp
addl %ecx, %eax
movl %eax, 0x38(%r14)
testl %ecx, %ecx
jle 0x2bfcda
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %r12
xorl %r13d, %r13d
movl %ebp, %r15d
movq 0x20(%rbx), %rax
movq 0x8(%rax,%r13), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x2c3399
incl %r15d
addq $0x18, %r13
cmpq %r13, %r12
jne 0x2bfcba
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_O3/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 0x2c00d4
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
movq %rax, %r15
jmp 0x2c00d7
xorl %r15d, %r15d
cmpb $0x0, 0x61(%rbx)
jne 0x2c00ea
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2bc7e9
testq %r15, %r15
je 0x2c0104
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a6164
addq $0x8, %rsp
popq %rbx
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: 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 0x2c0814
cmpl $0xad, %eax
jne 0x2c0835
movq %r15, %rdi
movl %ebx, %esi
callq 0x2c0855
movq %rax, (%r14)
addl 0x2c(%r15), %ebx
jmp 0x2c082d
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 0x2be5d4
// File: /workspace/github_c_makefile_star2_O3/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 0x2c0864
movb 0x2(%rax), %dl
movq %rax, %rdi
cmpb $-0x52, %dl
je 0x2c087b
movzbl %dl, %edx
cmpl $0x88, %edx
jne 0x2c08a3
movq 0x20(%rax), %rdi
movq 0x20(%rdi), %rdx
cmpl $0x2, (%rdx)
jl 0x2c08a3
cmpb $-0x78, %cl
je 0x2c088f
cmpb $-0x78, 0x2(%rax)
jne 0x2c0893
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_O3/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 0x2c08b0
movq 0x10(%rdi), %rdi
jmp 0x2c08a4
movzbl (%rdi), %eax
cmpl $0xad, %eax
je 0x2c08cb
cmpl $0x88, %eax
jne 0x2c08ce
movq 0x20(%rdi), %rax
movq 0x20(%rax), %rax
jmp 0x2c0916
movb 0x2(%rdi), %al
cmpb $0x24, %al
je 0x2c091f
movl %eax, %ecx
andb $-0x3, %cl
cmpb $-0x5c, %cl
jne 0x2c08e5
movq 0x40(%rdi), %rcx
testq %rcx, %rcx
jne 0x2c092e
cmpb $-0x52, %al
je 0x2c0912
movzbl %al, %eax
cmpl $0xaf, %eax
jne 0x2c092a
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movswq 0x30(%rdi), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
addq $0x8, %rax
jmp 0x2c091a
movq 0x20(%rdi), %rax
addq $0x8, %rax
movq (%rax), %rdi
jmp 0x2c08a4
movq 0x8(%rdi), %rdi
xorl %esi, %esi
jmp 0x2be46c
movb 0x1(%rdi), %al
retq
movswq 0x30(%rdi), %rax
testq %rax, %rax
js 0x2c0945
movq 0x8(%rcx), %rcx
shlq $0x5, %rax
movb 0x19(%rcx,%rax), %al
retq
movb $0x44, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c08a4
cmpb $0x41, %al
setl %cl
cmpb $0x41, %bl
setl %dl
orb %cl, %dl
jne 0x2c0978
cmpb $0x43, %al
setae %al
addb %al, %al
orb $0x41, %al
cmpb $0x43, %bl
movzbl %al, %ecx
movl $0x43, %eax
cmovbl %ecx, %eax
jmp 0x2c0985
cmpb $0x41, %al
movzbl %bl, %ecx
movzbl %al, %eax
cmovll %ecx, %eax
orb $0x40, %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %r14
movq %rbx, %rdi
callq *0x8(%rbx)
testl %eax, %eax
jne 0x2c0b2c
movzwl 0x5(%r14), %eax
testl $0x8040, %eax           # imm = 0x8040
jne 0x2c0b4e
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x2c0acc
movq %rbx, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0b31
movq 0x18(%r14), %rsi
testq %rsi, %rsi
jne 0x2c0a96
movl 0x4(%r14), %eax
btl $0xb, %eax
movq 0x20(%r14), %r15
jb 0x2c0b38
testq %r15, %r15
je 0x2c0b18
movl (%r15), %ebp
testl %ebp, %ebp
jle 0x2c0b18
addq $0x8, %r15
incl %ebp
movq (%r15), %rsi
testq %rsi, %rsi
je 0x2c0b09
movq %rbx, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0b31
addq $0x18, %r15
decl %ebp
cmpl $0x1, %ebp
jg 0x2c0af5
movl 0x4(%r14), %eax
btl $0x18, %eax
jae 0x2c0b4e
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x2c0d13
jmp 0x2c0b43
andl $0x2, %eax
jmp 0x2c0b50
movl $0x2, %eax
jmp 0x2c0b50
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2c0b5b
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x2c0b50
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
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: 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 0x2c0cae
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x2c0cae
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%r15)
testl %eax, %eax
jne 0x2c0cb9
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x2c0cc0
testl %eax, %eax
jne 0x2c0ca9
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x2c0bbe
movq %r15, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0ca9
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x2c0cc0
testl %eax, %eax
jne 0x2c0ca9
movq 0x40(%r14), %rsi
testq %rsi, %rsi
je 0x2c0beb
movq %r15, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0ca9
movq 0x48(%r14), %rsi
movq %r15, %rdi
callq 0x2c0cc0
testl %eax, %eax
jne 0x2c0ca9
movq 0x60(%r14), %rsi
testq %rsi, %rsi
je 0x2c0c18
movq %r15, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0ca9
movq (%r15), %rax
testq %rax, %rax
je 0x2c0c39
cmpb $0x2, 0x11c(%rax)
jb 0x2c0c39
movq 0x78(%r14), %rsi
movq %r15, %rdi
callq 0x2c0d13
testl %eax, %eax
jne 0x2c0ca9
movq 0x28(%r14), %r12
testq %r12, %r12
je 0x2c0c89
movl (%r12), %ebp
testl %ebp, %ebp
jle 0x2c0c89
addq $0x30, %r12
incl %ebp
movq (%r12), %rsi
testq %rsi, %rsi
je 0x2c0c65
movq %r15, %rdi
callq 0x2c0b5b
testl %eax, %eax
jne 0x2c0ca9
testb $0x4, 0x15(%r12)
je 0x2c0c7e
movq 0x38(%r12), %rsi
movq %r15, %rdi
callq 0x2c0cc0
testl %eax, %eax
jne 0x2c0ca9
addq $0x70, %r12
decl %ebp
cmpl $0x1, %ebp
jg 0x2c0c50
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x2c0c9a
movq %r15, %rdi
movq %r14, %rsi
callq *%rax
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x2c0b7f
jmp 0x2c0cae
movl $0x2, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andl $0x2, %eax
movl %eax, %ebx
jmp 0x2c0cae
// File: /workspace/github_c_makefile_star2_O3/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 0x2c0d8f
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %ebp
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2c0cc0
testl %eax, %eax
jne 0x2c0d91
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x2c0cc0
testl %eax, %eax
jne 0x2c0d91
movq 0x48(%rbx), %rsi
testq %rsi, %rsi
je 0x2c0d5c
movq %r14, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0d91
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x2c0d71
movq %r14, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0d91
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x2c0d86
movq %r14, %rdi
callq 0x2c0a8c
testl %eax, %eax
jne 0x2c0d91
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x2c0d27
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c125d
movq %rdx, %r15
movq %rsi, %r12
movb 0x20(%rsi), %al
cmpb 0x20(%rdx), %al
jne 0x2c125d
movb 0x21(%r12), %al
cmpb 0x21(%r15), %al
jne 0x2c125d
movb 0x22(%r12), %al
cmpb 0x22(%r15), %al
jne 0x2c125d
movb 0x24(%r12), %al
cmpb 0x24(%r15), %al
jne 0x2c125d
movq %rdi, %r14
movq 0x28(%r12), %rsi
movq 0x28(%r15), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2c0d98
testl %eax, %eax
jne 0x2c125d
movq 0x30(%r12), %rsi
movq 0x30(%r15), %rdx
movq %r14, %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2c0d98
testl %eax, %eax
jne 0x2c125d
movq 0x10(%r12), %rdi
movq 0x10(%r15), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2c128a
testl %eax, %eax
jne 0x2c125b
movq 0x18(%r12), %rdi
movq 0x18(%r15), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2c128a
testl %eax, %eax
je 0x2c1268
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x2c1286
movq 0x48(%r12), %rsi
movq 0x48(%r15), %rdx
movq %r14, %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2c0d98
testl %eax, %eax
jne 0x2c125b
xorl %ebx, %ebx
jmp 0x2c125d
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
movq %rdi, %rcx
orq %rsi, %rcx
je 0x2c130c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0x2c12fe
movl (%r15), %ecx
cmpl (%r14), %ecx
jne 0x2c12fe
testl %ecx, %ecx
jle 0x2c1303
movl $0x18, %r12d
xorl %r13d, %r13d
movb (%r15,%r12), %al
cmpb (%r14,%r12), %al
jne 0x2c12fe
movq -0x10(%r14,%r12), %rdx
movq -0x10(%r15,%r12), %rsi
xorl %edi, %edi
movl %ebx, %ecx
callq 0x2c0d98
testl %eax, %eax
jne 0x2c1303
incq %r13
movslq (%r15), %rcx
addq $0x18, %r12
xorl %eax, %eax
cmpq %rcx, %r13
jl 0x2c12ca
jmp 0x2c1303
movl $0x1, %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: 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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2c1364
movq 0x80(%rdi), %r15
movslq %esi, %rax
imulq $0x38, %rax, %r12
testb $0x1, -0x30(%r15,%r12)
jne 0x2c1364
movq (%rdi), %r14
movl $0x38, %esi
movq %r14, %rdi
callq 0x279b27
testq %rax, %rax
je 0x2c1364
movq %rax, %rbx
leaq (%r15,%r12), %rsi
addq $-0x38, %rsi
movw $0x1, 0x8(%rax)
movq %r14, 0x28(%rax)
movq %rax, %rdi
callq 0x278985
jmp 0x2c1366
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c0d98
movl $0x1, %ebx
testl %eax, %eax
je 0x2c13ed
movb (%r12), %al
cmpb $0x2b, %al
jne 0x2c13ce
movq 0x10(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x2c1375
testl %eax, %eax
jne 0x2c13ed
movq 0x18(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x2c1375
testl %eax, %eax
jne 0x2c13ed
movb (%r12), %al
cmpb $0x33, %al
jne 0x2c13eb
movq 0x10(%r12), %rdx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x2c14cd
testl %eax, %eax
jne 0x2c13ed
xorl %ebx, %ebx
movl %ebx, %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: 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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x2c14c5
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl 0x4(%rbx), %ecx
testl $0x41000, %ecx          # imm = 0x41000
je 0x2c143c
btl $0x12, %ecx
jb 0x2c1427
addq $0x10, %rbx
jmp 0x2c142f
movq 0x20(%rbx), %rbx
addq $0x8, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2c1410
jmp 0x2c14bd
movzbl (%rbx), %ecx
cmpl $0x33, %ecx
je 0x2c1482
cmpl $0x2c, %ecx
jne 0x2c1461
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x2c13f8
testl %eax, %eax
jne 0x2c14c6
movq 0x18(%rbx), %rbx
cmpb $0x2c, (%rbx)
je 0x2c1449
leaq 0x1df(%rip), %rax       # 0x2c1647
movq %rax, 0x8(%rsp)
movw $0x0, 0x24(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %ebp, 0x28(%rsp)
jmp 0x2c14aa
movq 0x10(%rbx), %rbx
leaq 0x1ba(%rip), %rcx       # 0x2c1647
movq %rcx, 0x8(%rsp)
movw $0x0, 0x24(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movl %ebp, 0x28(%rsp)
testq %rbx, %rbx
je 0x2c14bd
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c0a8c
movzwl 0x24(%r14), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %eax
jmp 0x2c14bd
// File: /workspace/github_c_makefile_star2_O3/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 0x2c1790
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 0x2c1821
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 0x284ab7
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 0x2a83e1
movq %r12, %rdi
movl %eax, %esi
movq %r15, %rdx
movl $0xfffffff9, %ecx       # imm = 0xFFFFFFF9
callq 0x27b778
testb %bpl, %bpl
je 0x2c1821
movl %r14d, 0x128(%rbx)
addq $0xd0, %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: 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 0x10(%rsi), %rax
movb (%rax), %cl
cmpb $-0x53, %cl
jne 0x2c183f
movb 0x2(%rax), %cl
pushq %rbx
movq %rax, %rdx
cmpb $-0x52, %cl
je 0x2c1857
movzbl %cl, %ecx
cmpl $0x88, %ecx
jne 0x2c1877
movq 0x20(%rax), %rdx
movq 0x20(%rdx), %rcx
movl (%rcx), %ecx
testb $0x8, 0x5(%rsi)
jne 0x2c1882
cmpl $0x1, %ecx
je 0x2c1890
movq %rax, %rsi
callq 0x2c26ad
movl $0x1, %ebx
jmp 0x2c18ad
movl $0x1, %ecx
testb $0x8, 0x5(%rsi)
je 0x2c1890
movq 0x20(%rsi), %rax
movq 0x20(%rax), %rax
movl (%rax), %edx
cmpl %edx, %ecx
jne 0x2c1894
xorl %ebx, %ebx
jmp 0x2c18ad
movl $0x1, %ebx
cmpl $0x0, 0x30(%rdi)
jne 0x2c18ad
leaq 0x115d97(%rip), %rsi    # 0x3d763d
xorl %eax, %eax
callq 0x27b48d
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c18c9
movb 0x2(%rbx), %al
movq %rbx, %rcx
cmpb $-0x52, %al
je 0x2c18e4
movzbl %al, %eax
movl $0x1, %r15d
cmpl $0x88, %eax
jne 0x2c18eb
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rax
movl (%rax), %r15d
testb $0x8, 0x5(%rsi)
jne 0x2c18f6
xorl %r13d, %r13d
jmp 0x2c18fa
movq 0x20(%rsi), %r13
movq (%rdi), %rdi
leal 0x1(%r15), %eax
movslq %eax, %rsi
testq %rdi, %rdi
je 0x2c1910
callq 0x282a35
jmp 0x2c1918
movq %rsi, %rdi
callq 0x272ae6
movq %rax, %r14
testq %rax, %rax
je 0x2c1976
movq %r15, (%rsp)
testl %r15d, %r15d
jle 0x2c196d
movl (%rsp), %ebp
movl $0x8, %r12d
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2c0855
movq %rax, %rdi
callq 0x2c08a4
testq %r13, %r13
je 0x2c195d
movq 0x20(%r13), %rcx
movq (%rcx,%r12), %rdi
movsbl %al, %esi
callq 0x2c0948
movb %al, (%r14,%r15)
incq %r15
addq $0x18, %r12
cmpq %r15, %rbp
jne 0x2c1935
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_O3/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 0x2c2644
movq 0x10(%rdi), %rdi
jmp 0x2c262e
cmpl $0xad, %ecx
jne 0x2c264f
movb 0x2(%rdi), %al
movzbl %al, %eax
leal -0x96(%rax), %ecx
cmpl $0x3, %ecx
jb 0x2c26a4
cmpl $0x73, %eax
je 0x2c26a4
cmpl $0xa4, %eax
jne 0x2c26a7
movl $0x1, %eax
testb $0x10, 0x6(%rdi)
jne 0x2c26ac
movq 0x40(%rdi), %rdx
testq %rdx, %rdx
je 0x2c26ac
movswq 0x30(%rdi), %rcx
testq %rcx, %rcx
js 0x2c26a4
movq 0x8(%rdx), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0x2c26ac
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_O3/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 0x2c26c1
leaq 0x114f0f(%rip), %rsi    # 0x3d75c9
xorl %eax, %eax
jmp 0x27b48d
cmpl $0x0, 0x30(%rdi)
je 0x2c26c8
retq
movq 0x20(%rsi), %rax
movq 0x20(%rax), %rax
movl (%rax), %edx
leaq 0x114f64(%rip), %rsi    # 0x3d763d
movl $0x1, %ecx
xorl %eax, %eax
jmp 0x27b48d
// File: /workspace/github_c_makefile_star2_O3/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 0x2c2715
orl %edx, %eax
movl %eax, 0x74(%rdi)
cmpl $0x1, %ecx
je 0x284b82
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a83e1
movq %rbx, %rdi
movl $0x25, %esi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl %eax, %ebp
movq %rbx, %rdi
movl $0x59, %esi
movl %r15d, %edx
xorl %ecx, %ecx
movl %r14d, %r8d
callq 0x2a83e1
movslq 0x90(%rbx), %rax
testq %rax, %rax
jle 0x2c2782
movq 0x88(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
movw $0x80, -0x16(%rcx,%rdx,8)
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2c2794
leaq 0x1fc6f6(%rip), %rcx    # 0x4bee88
jmp 0x2c27ae
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_O3/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 0x2c27c9
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 0x28fb69
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_O3/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 0x2919d2
movq %rax, 0x50(%r15)
testq %rax, %rax
je 0x2c2850
movl %r12d, 0x48(%r15)
movl 0x90(%r14), %ecx
movslq %ebx, %rdx
movl %ecx, (%rax,%rdx,4)
jmp 0x2c2858
movl $0x0, 0x48(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c2f92
cmpb $-0x51, (%rdi)
je 0x2c2f92
testb $0x1, 0x7(%rdi)
jne 0x2c2f92
movl $0x2c, %ebx
cmpq $0x0, 0x10(%rdi)
jne 0x2c2f92
cmpq $0x0, 0x20(%rdi)
movl $0x10, %eax
movl $0x2c, %ebx
cmovel %eax, %ebx
testb $0x4, 0x5(%rdi)
jne 0x2c2faf
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2c2faf
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_O3/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 0x2c3017
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x90, %esi
callq 0x279b27
testq %rax, %rax
je 0x2c3017
movq %rax, %rbx
movq (%r14), %rsi
movq %r12, %rdi
callq 0x279928
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x279928
movq %rax, 0x8(%rbx)
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x2c301e
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
jmp 0x2c3020
xorl %ebx, %ebx
jmp 0x2c30d6
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 0x2c2deb
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x2c2deb
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 0x7c(%r14), %eax
movl %eax, 0x7c(%rbx)
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
movb 0x8c(%r14), %al
movb %al, 0x8c(%rbx)
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x2c30aa
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
movq %rax, %r13
movq %r13, 0x28(%rbx)
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x2c30c5
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2c2864
jmp 0x2c30c7
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_O3/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 0x2c3302
movq %rsi, %r15
movq %rdi, %r14
movl $0x10, %esi
callq 0x282a35
testq %rax, %rax
je 0x2c3302
movq %rax, %rbx
movslq 0x8(%r15), %rsi
movl %esi, 0x8(%rax)
shlq $0x4, %rsi
movq %r14, %rdi
callq 0x282a35
movq %rax, (%rbx)
testq %rax, %rax
je 0x2c32f7
cmpl $0x0, 0x8(%r15)
jle 0x2c3304
movl $0x8, %r12d
xorl %r13d, %r13d
movq %r14, (%rsp)
movq (%rbx), %rbp
movq (%r15), %r14
movq -0x8(%r14,%r12), %rsi
movq (%rsp), %rdi
callq 0x279928
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 0x2c32c3
jmp 0x2c3304
movq %r14, %rdi
movq %rbx, %rsi
callq 0x282904
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_O3/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 0x2c3333
testb $0x1, 0x7(%rsi)
je 0x2c3333
pushq %rax
movq 0x28(%rdi), %rdi
movq 0x40(%rsi), %rsi
callq 0x2c3340
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c3398
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rsi
addq $0x70, %r14
testq %rsi, %rsi
je 0x2c3382
xorl %edi, %edi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2c11a3
testl %eax, %eax
jne 0x2c3391
movq (%r14), %rax
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x2c338a
leaq 0x40(%rbx), %rcx
movq %rcx, 0x38(%rax)
jmp 0x2c338a
movq $0x0, 0x40(%rbx)
movq %rbx, (%r14)
movq %r14, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq