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: whereUsablePartialIndex
static int whereUsablePartialIndex(
  int iTab,             /* The table for which we want an index */
  int isLeft,           /* True if iTab is the right table of a LEFT JOIN */
  WhereClause *pWC,     /* The WHERE clause of the query */
  Expr *pWhere          /* The WHERE clause from the partial index */
){
  int i;
  WhereTerm *pTerm;
  Parse *pParse = pWC->pWInfo->pParse;
  while( pWhere->op==TK_AND ){
    if( !whereUsablePartialIndex(iTab,isLeft,pWC,pWhere->pLeft) ) return 0;
    pWhere = pWhere->pRight;
  }
  if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0;
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr;
    pExpr = pTerm->pExpr;
    if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
     && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
     && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
movq (%rdx), %rax
movq (%rax), %r12
cmpb $0x2c, (%rcx)
jne 0x2e4f5d
movq 0x10(%rbx), %rcx
movl %r15d, %edi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2e4f1e
testl %eax, %eax
je 0x2e4fca
movq 0x18(%rbx), %rbx
cmpb $0x2c, (%rbx)
je 0x2e4f3f
movq (%r12), %rcx
xorl %eax, %eax
testb $-0x80, 0x32(%rcx)
cmovneq %rax, %r12
movq %r12, (%rsp)
cmpl $0x0, 0x14(%r14)
jle 0x2e4fd3
movq 0x20(%r14), %r13
xorl %r12d, %r12d
movq (%r13), %rsi
movl 0x4(%rsi), %eax
testb $0x1, %al
je 0x2e4fa1
testb $0x1, %al
sete %al
testl %ebp, %ebp
setne %cl
testb %al, %cl
jne 0x2e4fbd
movswl 0x34(%rsi), %eax
cmpl %r15d, %eax
je 0x2e4faa
jmp 0x2e4fbd
testl %ebp, %ebp
je 0x2e4faa
andl $0x1, %eax
je 0x2e4fbd
movq (%rsp), %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x2caad7
testl %eax, %eax
jne 0x2e4fce
incl %r12d
addq $0x40, %r13
cmpl 0x14(%r14), %r12d
jl 0x2e4f7d
xorl %eax, %eax
jmp 0x2e4fd3
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCoveredByIndex
SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(
  Expr *pExpr,        /* The index to be tested */
  int iCur,           /* The cursor number for the corresponding table */
  Index *pIdx         /* The index that might be used for coverage */
){
  Walker w;
  struct IdxCover xcov;
  memset(&w, 0, sizeof(w));
  xcov.iCur = iCur;
  xcov.pIdx = pIdx;
  w.xExprCallback = exprIdxCover;
  w.u.pIdxCover = &xcov;
  sqlite3WalkExpr(&w, pExpr);
  return !w.eCode;
}

// Assembly:
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x38(%rsp), %rcx
movl %esi, 0x8(%rcx)
movq %rdx, (%rcx)
leaq 0x8d2(%rip), %rdx       # 0x2e5a10
movq %rdx, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
testq %rdi, %rdi
je 0x2e515b
movq %rdi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x2ca211
xorl %eax, %eax
cmpw $0x0, 0x24(%rsp)
sete %al
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprIdxCover
static int exprIdxCover(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_COLUMN
   && pExpr->iTable==pWalker->u.pIdxCover->iCur
   && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
  ){
    pWalker->eCode = 1;
    return WRC_Abort;
  }
  return WRC_Continue;
}

// Assembly:
xorl %eax, %eax
cmpb $-0x5c, (%rsi)
jne 0x2e5a5b
movl 0x2c(%rsi), %edx
movq 0x28(%rdi), %rcx
cmpl 0x8(%rcx), %edx
jne 0x2e5a5b
movq (%rcx), %rcx
movzwl 0x60(%rcx), %eax
testq %rax, %rax
je 0x2e5a50
movzwl 0x30(%rsi), %edx
movq 0x8(%rcx), %rsi
xorl %ecx, %ecx
cmpw %dx, (%rsi,%rcx,2)
je 0x2e5a49
incq %rcx
cmpq %rcx, %rax
jne 0x2e5a39
jmp 0x2e5a50
xorl %eax, %eax
testw %cx, %cx
jns 0x2e5a5b
movw $0x1, 0x24(%rdi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: translateColumnToCopy
static void translateColumnToCopy(
  Parse *pParse,      /* Parsing context */
  int iStart,         /* Translate from this opcode to the end */
  int iTabCur,        /* OP_Column/OP_Rowid references to this table */
  int iRegister,      /* The first column is in this register */
  int iAutoidxCur     /* If non-zero, cursor of autoindex being generated */
){
  Vdbe *v = pParse->pVdbe;
  VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
  int iEnd = sqlite3VdbeCurrentAddr(v);
  if( pParse->db->mallocFailed ) return;
  for(; iStart<iEnd; iStart++, pOp++){
    if( pOp->p1!=iTabCur ) continue;
    if( pOp->opcode==OP_Column ){
      pOp->opcode = OP_Copy;
      pOp->p1 = pOp->p2 + iRegister;
      pOp->p2 = pOp->p3;
      pOp->p3 = 0;
    }else if( pOp->opcode==OP_Rowid ){
      if( iAutoidxCur ){
        pOp->opcode = OP_Sequence;
        pOp->p1 = iAutoidxCur;
      }else{
        pOp->opcode = OP_Null;
        pOp->p1 = 0;
        pOp->p3 = 0;
      }
    }
  }
}

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

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

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

// Assembly:
testl %esi, %esi
jle 0x2e6fe1
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %r13d
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x2c9ff3
movq %rax, %r12
movsbl (%rbx,%r15), %esi
movq %rax, %rdi
callq 0x2ca0e4
cmpb $0x41, %al
je 0x2e6fcb
movsbl (%rbx,%r15), %esi
movq %r12, %rdi
callq 0x2e7397
testl %eax, %eax
je 0x2e6fd0
movb $0x41, (%rbx,%r15)
incq %r15
cmpq %r15, %r13
jne 0x2e6f9b
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: codeApplyAffinity
static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
  Vdbe *v = pParse->pVdbe;
  if( zAff==0 ){
    assert( pParse->db->mallocFailed );
    return;
  }
  assert( v!=0 );

  /* Adjust base and n to skip over SQLITE_AFF_BLOB and SQLITE_AFF_NONE
  ** entries at the beginning and end of the affinity string.
  */
  assert( SQLITE_AFF_NONE<SQLITE_AFF_BLOB );
  while( n>0 && zAff[0]<=SQLITE_AFF_BLOB ){
    n--;
    base++;
    zAff++;
  }
  while( n>1 && zAff[n-1]<=SQLITE_AFF_BLOB ){
    n--;
  }

  /* Code the OP_Affinity opcode if there is anything left to do. */
  if( n>0 ){
    sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rcx, %rcx
je 0x2e706b
movl %edx, %ebx
testl %edx, %edx
jle 0x2e7013
movl %ebx, %r14d
addq %rcx, %r14
leal (%rbx,%rsi), %edx
cmpb $0x41, (%rcx)
jg 0x2e7013
leal -0x1(%rbx), %eax
incl %esi
incq %rcx
cmpl $0x1, %ebx
movl %eax, %ebx
jg 0x2e6ffb
xorl %ebx, %ebx
jmp 0x2e7018
movq %rcx, %r14
movl %esi, %edx
movq 0x10(%rdi), %r15
movl %ebx, %ecx
testl %ebx, %ebx
movl $0x1, %eax
cmovlel %ebx, %eax
incl %ebx
cmpl $0x2, %ecx
jl 0x2e703f
decl %ebx
cmpb $0x42, -0x1(%r14,%rcx)
leaq -0x1(%rcx), %rcx
jl 0x2e702a
jmp 0x2e7041
movl %eax, %ebx
testl %ebx, %ebx
jle 0x2e706b
movq %r15, %rdi
movl $0x5a, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x285198
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: codeDeferredSeek
static void codeDeferredSeek(
  WhereInfo *pWInfo,              /* Where clause context */
  Index *pIdx,                    /* Index scan is using */
  int iCur,                       /* Cursor for IPK b-tree */
  int iIdxCur                     /* Index cursor */
){
  Parse *pParse = pWInfo->pParse; /* Parse context */
  Vdbe *v = pParse->pVdbe;        /* Vdbe to generate code within */

  assert( iIdxCur>0 );
  assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x2c, (%rdi)
jne 0x2e7352
movq 0x10(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x2e7325
movq 0x18(%r14), %r14
cmpb $0x2c, (%r14)
je 0x2e733a
cmpl $0x0, 0x14(%rbx)
jle 0x2e738e
movq 0x20(%rbx), %r15
addq $0x12, %r15
xorl %r12d, %r12d
testb $0x4, (%r15)
jne 0x2e7381
movq -0x12(%r15), %rsi
xorl %edi, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x2ca527
testl %eax, %eax
jne 0x2e7381
orb $0x4, (%r15)
incl %r12d
addq $0x40, %r15
cmpl 0x14(%rbx), %r12d
jl 0x2e7363
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: sqlite3ExprNeedsNoAffinityChange
SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
  u8 op;
  int unaryMinus = 0;
  if( aff==SQLITE_AFF_BLOB ) return 1;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
    if( p->op==TK_UMINUS ) unaryMinus = 1;
    p = p->pLeft;
  }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_FLOAT: {
      return aff>=SQLITE_AFF_NUMERIC;
    }
    case TK_STRING: {
      return !unaryMinus && aff==SQLITE_AFF_TEXT;
    }
    case TK_BLOB: {
      return !unaryMinus;
    }
    case TK_COLUMN: {
      assert( p->iTable>=0 );  /* p cannot be part of a CHECK constraint */
      return aff>=SQLITE_AFF_NUMERIC && p->iColumn<0;
    }
    default: {
      return 0;
    }
  }
}

// Assembly:
movl $0x1, %eax
cmpb $0x41, %sil
jne 0x2e73a3
retq
xorl %ecx, %ecx
movb (%rdi), %dl
movzbl %dl, %r8d
leal -0xaa(%r8), %r9d
cmpl $0x2, %r9d
jae 0x2e73c4
cmpb $-0x56, %dl
cmovel %eax, %ecx
movq 0x10(%rdi), %rdi
jmp 0x2e73a5
cmpl $0xad, %r8d
jne 0x2e73d0
movb 0x2(%rdi), %dl
movzbl %dl, %edx
xorl %eax, %eax
cmpl $0x96, %edx
jle 0x2e73f7
cmpl $0x97, %edx
je 0x2e740e
cmpl $0xa4, %edx
je 0x2e7416
cmpl $0x98, %edx
je 0x2e7404
jmp 0x2e73a2
cmpl $0x73, %edx
je 0x2e7424
cmpl $0x96, %edx
jne 0x2e73a2
xorl %eax, %eax
cmpb $0x43, %sil
setge %al
retq
xorl %eax, %eax
testl %ecx, %ecx
sete %al
retq
cmpb $0x43, %sil
jl 0x2e73a2
movzwl 0x30(%rdi), %eax
shrl $0xf, %eax
retq
testl %ecx, %ecx
sete %al
cmpb $0x42, %sil
sete %cl
andb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: whereIndexExprTransNode
static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
  IdxExprTrans *pX = p->u.pIdxTrans;
  if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
    preserveExpr(pX, pExpr);
    pExpr->affExpr = sqlite3ExprAffinity(pExpr);
    pExpr->op = TK_COLUMN;
    pExpr->iTable = pX->iIdxCur;
    pExpr->iColumn = pX->iIdxCol;
    pExpr->y.pTab = 0;
    testcase( ExprHasProperty(pExpr, EP_Skip) );
    testcase( ExprHasProperty(pExpr, EP_Unlikely) );
    ExprClearProperty(pExpr, EP_Skip|EP_Unlikely);
    return WRC_Prune;
  }else{
    return WRC_Continue;
  }
}

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

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq $0x0, (%rsp)
testq %rsi, %rsi
je 0x2e7633
movzbl 0x5e(%rdi), %edx
movq %rsp, %r8
movl $0x43, %ecx
callq 0x2c9ac1
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x2e764e
movq %rbx, %rdi
callq 0x281c1d
xorl %ebp, %ebp
testl %eax, %eax
setg %bpl
jmp 0x2e7650
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x281de6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowIfNewPeer
static void windowIfNewPeer(
  Parse *pParse,
  ExprList *pOrderBy,
  int regNew,                     /* First in array of new values */
  int regOld,                     /* First in array of old values */
  int addr                        /* Jump here */
){
  Vdbe *v = sqlite3GetVdbe(pParse);
  if( pOrderBy ){
    int nVal = pOrderBy->nExpr;
    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0);
    sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal);
    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
    sqlite3VdbeAddOp3(v, OP_Jump,
      sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1
    );
    VdbeCoverageEqNe(v);
    sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1);
  }else{
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
callq 0x2c5ddf
movq %rax, %r15
testq %r13, %r13
je 0x2e823b
movl %r12d, 0x4(%rsp)
movl (%r13), %r12d
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2d7619
movq %rax, %r13
movq %r15, %rdi
movl $0x56, %esi
movl %ebx, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x2b200c
movq (%r15), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2e824d
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
movq %r13, %rdx
callq 0x29991d
jmp 0x2e8269
movq %r15, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
jmp 0x2e8298
movq 0x88(%r15), %rax
movslq 0x90(%r15), %rcx
leaq (%rcx,%rcx,2), %rcx
movb $-0x9, -0x17(%rax,%rcx,8)
movq %r13, -0x8(%rax,%rcx,8)
movl 0x90(%r15), %edx
incl %edx
movq %r15, %rdi
movl $0x10, %esi
movl 0x4(%rsp), %ecx
movl %edx, %r8d
callq 0x2b200c
decl %r12d
movq %r15, %rdi
movl $0x4d, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl %r12d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b200c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowReadPeerValues
static void windowReadPeerValues(
  WindowCodeArg *p,
  int csr,
  int reg
){
  Window *pMWin = p->pMWin;
  ExprList *pOrderBy = pMWin->pOrderBy;
  if( pOrderBy ){
    Vdbe *v = sqlite3GetVdbe(p->pParse);
    ExprList *pPart = pMWin->pPartition;
    int iColOff = pMWin->nBufferCol + (pPart ? pPart->nExpr : 0);
    int i;
    for(i=0; i<pOrderBy->nExpr; i++){
      sqlite3VdbeAddOp3(v, OP_Column, csr, iColOff+i, reg+i);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r13
movq 0x18(%r13), %r15
testq %r15, %r15
je 0x2e8a60
movl %edx, %ebx
movl %esi, %ebp
movq (%rdi), %rdi
callq 0x2c5ddf
movq %rax, %r14
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x2e8a31
movl (%rax), %r12d
jmp 0x2e8a34
xorl %r12d, %r12d
cmpl $0x0, (%r15)
jle 0x2e8a60
addl 0x78(%r13), %r12d
xorl %r13d, %r13d
leal (%r12,%r13), %ecx
leal (%rbx,%r13), %r8d
movq %r14, %rdi
movl $0x59, %esi
movl %ebp, %edx
callq 0x2b200c
incl %r13d
cmpl (%r15), %r13d
jl 0x2e8a41
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: codeDistinct
static void codeDistinct(
  Parse *pParse,     /* Parsing and code generating context */
  int iTab,          /* A sorting index used to test for distinctness */
  int addrRepeat,    /* Jump to here if not distinct */
  int N,             /* Number of elements */
  int iMem           /* First element */
){
  Vdbe *v;
  int r1;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, %ecx
movl %esi, %r13d
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movb 0x1f(%rdi), %al
testb %al, %al
je 0x2e9001
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xd4(%rbx,%rax,4), %ebp
jmp 0x2e9009
movl 0x38(%rbx), %ebp
incl %ebp
movl %ebp, 0x38(%rbx)
movq %r14, %rdi
movl $0x1e, %esi
movl %r13d, %edx
movl %r12d, %r8d
callq 0x2b200c
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
jne 0x2e903c
movq 0x88(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
movb $-0x3, 0x1(%rcx,%rax,8)
movl %r15d, 0x10(%rcx,%rax,8)
movq %r14, %rdi
movl $0x5b, %esi
movl %r12d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
callq 0x2b200c
movq %r14, %rdi
movl $0x82, %esi
movl %r13d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x2b200c
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
jne 0x2e9087
movq 0x88(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
movb $-0x3, 0x1(%rcx,%rax,8)
movl %r15d, 0x10(%rcx,%rax,8)
movslq 0x90(%r14), %rax
testq %rax, %rax
jle 0x2e90a5
movq 0x88(%r14), %rcx
leaq (%rax,%rax,2), %rax
movw $0x10, -0x16(%rcx,%rax,8)
testl %ebp, %ebp
je 0x2e90c0
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x2e90c0
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xd4(%rbx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: makeSorterRecord
static int makeSorterRecord(
  Parse *pParse,
  SortCtx *pSort,
  Select *pSelect,
  int regBase,
  int nBase
){
  int nOBSat = pSort->nOBSat;
  Vdbe *v = pParse->pVdbe;
  int regOut = ++pParse->nMem;
  if( pSort->pDeferredRowLoad ){
    innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
  }
  sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
  return regOut;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl 0x8(%rsi), %r12d
movq 0x10(%rdi), %r15
movl 0x38(%rdi), %r14d
incl %r14d
movl %r14d, 0x38(%rdi)
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x2e95c1
movq 0x20(%rdx), %rsi
movl (%rax), %edx
movzbl 0x4(%rax), %r8d
xorl %ecx, %ecx
callq 0x2c82b9
addl %r12d, %ebp
subl %r12d, %ebx
movq %r15, %rdi
movl $0x5b, %esi
movl %ebp, %edx
movl %ebx, %ecx
movl %r14d, %r8d
callq 0x2b200c
movl %r14d, %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: havingToWhereExprCb
static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
  if( pExpr->op!=TK_AND ){
    Select *pS = pWalker->u.pSelect;
    if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
      sqlite3 *db = pWalker->pParse->db;
      Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
      if( pNew ){
        Expr *pWhere = pS->pWhere;
        SWAP(Expr, *pNew, *pExpr);
        pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
        pS->pWhere = pNew;
        pWalker->eCode = 1;
      }
    }
    return WRC_Prune;
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
xorl %ebp, %ebp
cmpb $0x2c, (%rsi)
je 0x2e96c5
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rdi), %r12
movq 0x38(%r12), %rcx
leaq 0x8(%rsp), %r15
movw $0x1, 0x24(%r15)
leaq 0xb1(%rip), %rdx        # 0x2e96d4
movq %rdx, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq %rcx, 0x28(%r15)
movq %rax, (%r15)
movq %r15, %rdi
callq 0x2ca211
cmpw $0x0, 0x24(%r15)
movl $0x1, %ebp
je 0x2e96c5
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x8e612(%rip), %rax     # 0x377c6a
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rdx)
movl $0x98, %esi
xorl %ecx, %ecx
callq 0x2bb38d
testq %rax, %rax
je 0x2e96c5
movq 0x30(%r12), %rdx
leaq 0x8(%rsp), %r8
movl $0x9, %ecx
movq %r8, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x9, %ecx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0x9, %ecx
movq %r14, %rdi
movq %r8, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq (%rbx), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2c02f0
movq %rax, 0x30(%r12)
movw $0x1, 0x24(%rbx)
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprNodeIsConstantOrGroupBy
static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
  ExprList *pGroupBy = pWalker->u.pGroupBy;
  int i;

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

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

  return exprNodeIsConstant(pWalker, pExpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, (%rsp)
movq 0x28(%rdi), %r13
cmpl $0x0, (%r13)
jle 0x2e975c
leaq 0x8(%r13), %rbp
xorl %r14d, %r14d
movq (%rbp), %r15
xorl %edi, %edi
movq %rbx, %rsi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2ca527
cmpl $0x1, %eax
ja 0x2e974c
movq (%rsp), %rax
movq (%rax), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b32a0
movq %rax, %rcx
testq %rax, %rax
jne 0x2e9735
movq (%r12), %rax
movq 0x10(%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x2e978b
leaq -0xc5eb(%rip), %rdx     # 0x2dd15b
cmpq %rdx, 0x18(%rcx)
je 0x2e978b
incq %r14
movslq (%r13), %rax
addq $0x18, %rbp
cmpq %rax, %r14
jl 0x2e96f8
testb $0x8, 0x5(%rbx)
jne 0x2e977c
movq (%rsp), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ca123
movq (%rsp), %rax
movw $0x0, 0x24(%rax)
movl $0x2, %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: sqlite3IsReadOnly
SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
  if( tabIsReadOnly(pParse, pTab) ){
    sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
    return 1;
  }
#ifndef SQLITE_OMIT_VIEW
  if( !viewOk && pTab->pSelect ){
    sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
    return 1;
  }
#endif
  return 0;
}

// Assembly:
pushq %rax
cmpl $0x0, 0x54(%rsi)
je 0x2e9d21
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x2e9d05
movq (%rdi), %rcx
cmpq %rcx, (%rax)
je 0x2e9d05
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x2e9cf7
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpq $0x0, 0x68(%rax)
sete %al
testb %al, %al
je 0x2e9d61
leaq 0xf8727(%rip), %rax     # 0x3e2446
jmp 0x2e9d75
movl 0x40(%rsi), %r8d
testl $0x1001, %r8d           # imm = 0x1001
je 0x2e9d61
movq (%rdi), %rax
movq 0x30(%rax), %rcx
testb $0x1, %r8b
jne 0x2e9d56
btl $0x1c, %ecx
jae 0x2e9d61
cmpq $0x0, 0x208(%rax)
jne 0x2e9d61
cmpl $0x0, 0xcc(%rax)
jne 0x2e9d61
jmp 0x2e9d18
andl $0x10000001, %ecx       # imm = 0x10000001
cmpl $0x1, %ecx
jne 0x2e9d89
xorl %eax, %eax
testl %edx, %edx
jne 0x2e9d87
cmpq $0x0, 0x18(%rsi)
je 0x2e9d87
leaq 0xf86ee(%rip), %rax     # 0x3e2463
movq (%rsi), %rdx
movq %rax, %rsi
xorl %eax, %eax
callq 0x284eb8
movl $0x1, %eax
popq %rcx
retq
cmpb $0x0, 0x1e(%rdi)
jmp 0x2e9d11
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3MaterializeView
SQLITE_PRIVATE void sqlite3MaterializeView(
  Parse *pParse,       /* Parsing context */
  Table *pView,        /* View definition */
  Expr *pWhere,        /* Optional WHERE clause to be added */
  ExprList *pOrderBy,  /* Optional ORDER BY clause */
  Expr *pLimit,        /* Optional LIMIT clause */
  int iCur             /* Cursor number for ephemeral table */
){
  SelectDest dest;
  Select *pSel;
  SrcList *pFrom;
  sqlite3 *db = pParse->db;
  int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
  pWhere = sqlite3ExprDup(db, pWhere, 0);
  pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0);
  if( pFrom ){
    assert( pFrom->nSrc==1 );
    pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
    pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
    assert( pFrom->a[0].pOn==0 );
    assert( pFrom->a[0].pUsing==0 );
  }
  pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, pOrderBy,
                          SF_IncludeHidden, pLimit);
  sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
  sqlite3Select(pParse, pSel, &dest);
  sqlite3SelectDelete(db, pSel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x70(%rsi), %rax
testq %rax, %rax
je 0x2e9de4
movq 0x20(%rbx), %rcx
addq $0x18, %rcx
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rsi, %rbp
leaq 0x20(%rcx), %rdi
cmpq %rax, (%rcx)
movq %rdi, %rcx
jne 0x2e9dcf
sarq $0x20, %rbp
jmp 0x2e9deb
movq $-0x8000, %rbp          # imm = 0x8000
testq %rdx, %rdx
je 0x2e9e04
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
movq %rax, %r12
jmp 0x2e9e07
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2bb525
movq %rax, %r13
testq %rax, %rax
je 0x2e9e44
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x283365
movq %rax, 0x18(%r13)
movq 0x20(%rbx), %rax
shlq $0x5, %rbp
movq (%rax,%rbp), %rsi
movq %rbx, %rdi
callq 0x283365
movq %rax, 0x10(%r13)
subq $0x8, %rsp
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rbp
pushq $0x20000                # imm = 0x20000
pushq %rbp
callq 0x2bb03c
addq $0x20, %rsp
movq %rax, %r15
leaq 0x10(%rsp), %rdx
movb $0xc, (%rdx)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rdx)
movl $0x0, 0x8(%rdx)
movq %rbp, 0x18(%rdx)
movq %rbp, 0xc(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b9266
testq %r15, %r15
je 0x2e9eba
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2afecb
addq $0x38, %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: sqlite3VtabMakeWritable
SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  int i, n;
  Table **apVtabLock;

  assert( IsVirtual(pTab) );
  for(i=0; i<pToplevel->nVtabLock; i++){
    if( pTab==pToplevel->apVtabLock[i] ) return;
  }
  n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
  apVtabLock = sqlite3Realloc(pToplevel->apVtabLock, n);
  if( apVtabLock ){
    pToplevel->apVtabLock = apVtabLock;
    pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
  }else{
    sqlite3OomFault(pToplevel->db);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xa0(%rdi), %r14
testq %r14, %r14
cmoveq %rdi, %r14
movslq 0x120(%r14), %rax
testq %rax, %rax
jle 0x2ea0d7
movq 0x178(%r14), %rcx
xorl %edx, %edx
cmpq %rbx, (%rcx,%rdx,8)
je 0x2ea10e
incq %rdx
cmpq %rdx, %rax
jne 0x2ea0c9
leal 0x8(,%rax,8), %eax
movq 0x178(%r14), %rdi
movslq %eax, %rsi
callq 0x27c4f3
testq %rax, %rax
je 0x2ea116
movq %rax, 0x178(%r14)
movslq 0x120(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x120(%r14)
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2824bb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: checkColumnOverlap
static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){
  int e;
  if( pIdList==0 || NEVER(pEList==0) ) return 1;
  for(e=0; e<pEList->nExpr; e++){
    if( sqlite3IdListIndex(pIdList, pEList->a[e].zEName)>=0 ) return 1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x1, %ebx
jne 0x2ea553
movq %rsi, %r14
movslq (%rsi), %rax
testq %rax, %rax
jle 0x2ea551
movq %rdi, %r15
shlq $0x3, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
movq 0x10(%r14,%r13), %rsi
movq %r15, %rdi
callq 0x2d244b
testl %eax, %eax
jns 0x2ea553
addq $0x18, %r13
cmpq %r13, %r12
jne 0x2ea537
xorl %ebx, %ebx
movl %ebx, %eax
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: sqlite3TriggerStepSrc
SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(
  Parse *pParse,       /* The parsing context */
  TriggerStep *pStep   /* The trigger containing the target token */
){
  sqlite3 *db = pParse->db;
  SrcList *pSrc;                  /* SrcList to be returned */
  char *zName = sqlite3DbStrDup(db, pStep->zTarget);
  pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
  assert( pSrc==0 || pSrc->nSrc==1 );
  assert( zName || pSrc==0 );
  if( pSrc ){
    Schema *pSchema = pStep->pTrig->pSchema;
    pSrc->a[0].zName = zName;
    if( pSchema!=db->aDb[1].pSchema ){
      pSrc->a[0].pSchema = pSchema;
    }
    if( pStep->pFrom ){
      SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0);
      pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup);
    }
  }else{
    sqlite3DbFree(db, zName);
  }
  return pSrc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x18(%rsi), %rsi
movq %r14, %rdi
callq 0x283365
movq %rax, %r13
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2bb525
testq %rax, %rax
je 0x2ebee1
movq %rax, %r15
movq 0x8(%r12), %rax
movq 0x28(%rax), %rax
movq %r13, 0x18(%r15)
movq 0x20(%r14), %rcx
cmpq 0x38(%rcx), %rax
je 0x2ebeb6
movq %rax, 0x8(%r15)
movq 0x20(%r12), %rsi
testq %rsi, %rsi
je 0x2ebef4
movq %r14, %rdi
xorl %edx, %edx
callq 0x2cc81d
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2bc484
testq %r13, %r13
je 0x2ebef1
movq %r14, %rdi
movq %r13, %rsi
callq 0x28c3e7
xorl %r15d, %r15d
movq %r15, %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: autoIncrementEnd
static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){
  AutoincInfo *p;
  Vdbe *v = pParse->pVdbe;
  sqlite3 *db = pParse->db;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rax, (%rsp)
leaq 0x98(%rdi), %rbp
movq (%rsp), %r13
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x2ece57
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movslq 0x10(%rbp), %r14
movl 0x14(%rbp), %r12d
movb 0x1f(%rbx), %al
testb %al, %al
movq %rcx, 0x10(%rsp)
je 0x2ecda6
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xd4(%rbx,%rax,4), %r15d
jmp 0x2ecdb1
movl 0x38(%rbx), %r15d
incl %r15d
movl %r15d, 0x38(%rbx)
leal 0x2(%r12), %edx
movl 0x90(%r13), %ecx
addl $0x7, %ecx
movq %r13, %rdi
movl $0x37, %esi
movl %r12d, %r8d
callq 0x2b200c
movl 0x10(%rbp), %edx
shlq $0x5, %r14
movq 0x10(%rsp), %rax
movq 0x18(%rax,%r14), %rax
movq 0x68(%rax), %rcx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x61, %r8d
callq 0x2c5fdd
movq %r13, %rdi
movl $0x5, %esi
leaq 0xf1c9c(%rip), %rdx     # 0x3deaa0
callq 0x2850a2
testq %rax, %rax
je 0x2ece57
leal 0x1(%r12), %ecx
movl %ecx, 0x4(%rax)
movl %ecx, 0x20(%rax)
decl %r12d
movl %r12d, 0x34(%rax)
movl %r15d, 0x3c(%rax)
movl %r15d, 0x50(%rax)
movl %ecx, 0x54(%rax)
movw $0x8, 0x4a(%rax)
testl %r15d, %r15d
je 0x2ece4e
movzbl 0x1f(%rbx), %ecx
cmpq $0x7, %rcx
ja 0x2ece4e
leal 0x1(%rcx), %edx
movb %dl, 0x1f(%rbx)
movl %r15d, 0xd4(%rbx,%rcx,4)
testq %rax, %rax
jne 0x2ecd6a
addq $0x18, %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: sqlite3ExprReferencesUpdatedColumn
SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(
  Expr *pExpr,    /* The expression to be checked */
  int *aiChng,    /* aiChng[x]>=0 if column x changed by the UPDATE */
  int chngRowid   /* True if UPDATE changes the rowid */
){
  Walker w;
  memset(&w, 0, sizeof(w));
  w.eCode = 0;
  w.xExprCallback = checkConstraintExprNode;
  w.u.aiCol = aiChng;
  sqlite3WalkExpr(&w, pExpr);
  if( !chngRowid ){
    testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
    w.eCode &= ~CKCNSTRNT_ROWID;
  }
  testcase( w.eCode==0 );
  testcase( w.eCode==CKCNSTRNT_COLUMN );
  testcase( w.eCode==CKCNSTRNT_ROWID );
  testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
  return w.eCode!=0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x2344(%rip), %rcx      # 0x2ef1c9
movq %rcx, 0x8(%rsp)
movq %rsi, 0x28(%rsp)
testq %rdi, %rdi
je 0x2ecea2
movq %rdi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x2ca211
testl %ebx, %ebx
jne 0x2eceab
andb $-0x3, 0x24(%rsp)
xorl %eax, %eax
cmpw $0x0, 0x24(%rsp)
setne %al
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: checkConstraintExprNode
static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_COLUMN ){
    assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
    if( pExpr->iColumn>=0 ){
      if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
        pWalker->eCode |= CKCNSTRNT_COLUMN;
      }
    }else{
      pWalker->eCode |= CKCNSTRNT_ROWID;
    }
  }
  return WRC_Continue;
}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testb $0x8, 0x40(%rdx)
je 0x2f011c
movq %rdi, %rax
movq (%rdi), %rdi
testb $0x4, 0x2c(%rdi)
jne 0x2f011c
movq %rdx, %r14
movl %esi, %ebp
movq 0xa0(%rax), %r15
testq %r15, %r15
cmoveq %rax, %r15
movq 0x20(%rdi), %rcx
movslq %esi, %rdx
shlq $0x5, %rdx
movq 0x18(%rcx,%rdx), %rcx
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
je 0x2f0112
testb $-0x80, 0x40(%rcx)
jne 0x2f0112
cmpl $0x0, 0x54(%rcx)
jne 0x2f0112
cmpw $0x2, 0x46(%rcx)
jne 0x2f0112
leaq 0x98(%r15), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2f0129
cmpq %r14, 0x8(%rax)
jne 0x2f0102
jmp 0x2f0165
incl 0x30(%rax)
movl $0x20b, 0x18(%rax)      # imm = 0x20B
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %esi
callq 0x28c518
testq %rax, %rax
je 0x2f011c
movq 0x98(%r15), %rcx
movq %rcx, (%rax)
movq %rax, 0x98(%r15)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movl 0x38(%r15), %ecx
leal 0x2(%rcx), %edx
movl %edx, 0x38(%r15)
movl %edx, 0x14(%rax)
addl $0x4, %ecx
movl %ecx, 0x38(%r15)
movl 0x14(%rax), %ebx
jmp 0x2f011c