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: sqlite3IdListAppend
SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
  sqlite3 *db = pParse->db;
  int i;
  if( pList==0 ){
    pList = sqlite3DbMallocZero(db, sizeof(IdList) );
    if( pList==0 ) return 0;
  }
  pList->a = sqlite3ArrayAllocate(
      db,
      pList->a,
      sizeof(pList->a[0]),
      &pList->nId,
      &i
  );
  if( i<0 ){
    sqlite3IdListDelete(db, pList);
    return 0;
  }
  pList->a[i].zName = sqlite3NameFromToken(db, pToken);
  if( IN_RENAME_OBJECT && pList->a[i].zName ){
    sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
  }
  return pList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r12
testq %rsi, %rsi
jne 0x2b6688
movl $0x10, %esi
movq %r12, %rdi
callq 0x279b27
movq %rax, %rbx
testq %rax, %rax
je 0x2b66ed
movq (%rbx), %rsi
leaq 0x8(%rbx), %rcx
leaq 0xc(%rsp), %r13
movq %r12, %rdi
movl $0x10, %edx
movq %r13, %r8
callq 0x2e07ad
movq %rax, (%rbx)
movslq (%r13), %r13
movq %r12, %rdi
testq %r13, %r13
js 0x2b66e5
movq %r14, %rsi
callq 0x2b1f02
movq (%rbx), %rcx
shlq $0x4, %r13
movq %rax, (%rcx,%r13)
testq %rax, %rax
je 0x2b66ef
cmpb $0x2, 0x11c(%r15)
jb 0x2b66ef
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2b1eb3
jmp 0x2b66ef
movq %rbx, %rsi
callq 0x2a6536
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
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: sqlite3ExprAddCollateToken
SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(
  Parse *pParse,           /* Parsing context */
  Expr *pExpr,             /* Add the "COLLATE" clause to this expression */
  const Token *pCollName,  /* Name of collating sequence */
  int dequote              /* True to dequote pCollName */
){
  if( pCollName->n>0 ){
    Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
    if( pNew ){
      pNew->pLeft = pExpr;
      pNew->flags |= EP_Collate|EP_Skip;
      pExpr = pNew;
    }
  }
  return pExpr;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, 0x8(%rdx)
je 0x2b69bb
movq (%rdi), %rdi
movl $0x6f, %esi
callq 0x2b1c27
testq %rax, %rax
je 0x2b69bb
movq %rbx, 0x10(%rax)
orb $0x11, 0x5(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAttachSubtrees
SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(
  sqlite3 *db,
  Expr *pRoot,
  Expr *pLeft,
  Expr *pRight
){
  if( pRoot==0 ){
    assert( db->mallocFailed );
    sqlite3ExprDelete(db, pLeft);
    sqlite3ExprDelete(db, pRight);
  }else{
    if( pRight ){
      pRoot->pRight = pRight;
      pRoot->flags |= EP_Propagate & pRight->flags;
    }
    if( pLeft ){
      pRoot->pLeft = pLeft;
      pRoot->flags |= EP_Propagate & pLeft->flags;
    }
    exprSetHeight(pRoot);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
testq %rsi, %rsi
je 0x2b6a03
testq %rbx, %rbx
je 0x2b69e0
movq %rbx, 0x18(%rsi)
movl $0x200104, %eax         # imm = 0x200104
andl 0x4(%rbx), %eax
orl %eax, 0x4(%rsi)
testq %rdx, %rdx
je 0x2b69f4
movq %rdx, 0x10(%rsi)
movl $0x200104, %eax         # imm = 0x200104
andl 0x4(%rdx), %eax
orl %eax, 0x4(%rsi)
movq %rsi, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e72fc
movq %rdi, %r14
testq %rdx, %rdx
je 0x2b6a16
movq %r14, %rdi
movq %rdx, %rsi
callq 0x2a6164
testq %rbx, %rbx
je 0x2b6a2d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a6164
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: sqlite3ExprFunction
SQLITE_PRIVATE Expr *sqlite3ExprFunction(
  Parse *pParse,        /* Parsing context */
  ExprList *pList,      /* Argument list */
  Token *pToken,        /* Name of the function */
  int eDistinct         /* SF_Distinct or SF_ALL or 0 */
){
  Expr *pNew;
  sqlite3 *db = pParse->db;
  assert( pToken );
  pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
  if( pNew==0 ){
    sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
    return 0;
  }
  if( pList && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
    sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken);
  }
  pNew->x.pList = pList;
  ExprSetProperty(pNew, EP_HasFunc);
  assert( !ExprHasProperty(pNew, EP_xIsSelect) );
  sqlite3ExprSetHeightAndFlags(pParse, pNew);
  if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct);
  return pNew;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r13
movq %r13, %rdi
movl $0xa9, %esi
movl $0x1, %ecx
callq 0x2b1c27
movq %rax, %rbx
testq %rax, %rax
je 0x2b6aad
testq %r14, %r14
je 0x2b6a8f
movl (%r14), %eax
movq (%r15), %rcx
cmpl 0x94(%rcx), %eax
jle 0x2b6a8f
leaq 0x1224a8(%rip), %rsi    # 0x3d8f2a
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x27b48d
movq %r14, 0x20(%rbx)
orb $0x4, 0x4(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b6cb8
cmpl $0x1, %ebp
jne 0x2b6abd
orb $0x2, 0x4(%rbx)
jmp 0x2b6abd
testq %r14, %r14
je 0x2b6abd
movq %r13, %rdi
movq %r14, %rsi
callq 0x2a65a3
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: sqlite3WindowAttach
SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){
  if( p ){
    assert( p->op==TK_FUNCTION );
    assert( pWin );
    p->y.pWin = pWin;
    ExprSetProperty(p, EP_WinFunc);
    pWin->pOwner = p;
    if( (p->flags & EP_Distinct) && pWin->eFrmType!=TK_FILTER ){
      sqlite3ErrorMsg(pParse,
          "DISTINCT is not supported for window functions"
      );
    }
  }else{
    sqlite3WindowDelete(pParse->db, pWin);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2b6af5
movq %rdx, 0x40(%rsi)
movl 0x4(%rsi), %eax
movl %eax, %ecx
orl $0x1000000, %ecx        # imm = 0x1000000
movl %ecx, 0x4(%rsi)
movq %rsi, 0x70(%rdx)
testb $0x2, %al
je 0x2b6af4
cmpb $-0x5d, 0x20(%rdx)
jne 0x2b6b00
retq
movq (%rdi), %rdi
movq %rdx, %rsi
jmp 0x2a6225
leaq 0x122445(%rip), %rsi    # 0x3d8f4c
xorl %eax, %eax
jmp 0x27b48d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAnd
SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
  sqlite3 *db = pParse->db;
  if( pLeft==0  ){
    return pRight;
  }else if( pRight==0 ){
    return pLeft;
  }else if( (ExprAlwaysFalse(pLeft) || ExprAlwaysFalse(pRight))
         && !IN_RENAME_OBJECT
  ){
    sqlite3ExprDelete(db, pLeft);
    sqlite3ExprDelete(db, pRight);
    return sqlite3Expr(db, TK_INTEGER, "0");
  }else{
    return sqlite3PExpr(pParse, TK_AND, pLeft, pRight);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
je 0x2b6ba8
movq %rsi, %rdx
testq %rbx, %rbx
je 0x2b6b65
movq (%rdi), %r14
movl $0x20000001, %eax       # imm = 0x20000001
movl 0x4(%rdx), %ecx
andl %eax, %ecx
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x2b6b48
andl 0x4(%rbx), %eax
cmpl $0x20000000, %eax       # imm = 0x20000000
jne 0x2b6b51
cmpb $0x1, 0x11c(%rdi)
jbe 0x2b6b6a
movl $0x2c, %esi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x2ad3b5
movq %rdx, %rbx
jmp 0x2b6ba8
movq %r14, %rdi
movq %rdx, %rsi
callq 0x2a6164
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a6164
leaq 0xb7e56(%rip), %rax     # 0x36e9dd
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movl $0x98, %esi
xorl %ecx, %ecx
callq 0x2b1c27
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %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: binaryToUnaryIfNull
static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
    sqlite3 *db = pParse->db;
    if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){
      pA->op = (u8)op;
      sqlite3ExprDelete(db, pA->pRight);
      pA->pRight = 0;
    }
  }

// Assembly:
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x2b6bf0
cmpb $0x77, (%rsi)
jne 0x2b6bf0
cmpb $0x1, 0x11c(%rdi)
ja 0x2b6bf0
movq (%rdi), %rdi
movb %cl, (%rbx)
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2b6be8
callq 0x2a6164
movq $0x0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprUnmapAndDelete
SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){
  if( p ){
    if( IN_RENAME_OBJECT ){
      sqlite3RenameExprUnmap(pParse, p);
    }
    sqlite3ExprDeleteNN(pParse->db, p);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2b6c67
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x11c(%rdi), %bpl
cmpb $0x2, %bpl
jb 0x2b6c54
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movq %r14, (%rdi)
leaq 0x12d19(%rip), %rax     # 0x2c9947
movq %rax, 0x8(%rdi)
leaq 0x12d32(%rip), %rax     # 0x2c996b
movq %rax, 0x10(%rdi)
movb $0x3, 0x11c(%r14)
movq %rbx, %rsi
callq 0x2c0a8c
movb %bpl, 0x11c(%r14)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2a6164
addq $0x30, %rsp
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: sqlite3ExprIsConstant
static int exprIsConst(Expr *p, int initFlag, int iCur){
  Walker w;
  w.eCode = initFlag;
  w.xExprCallback = exprNodeIsConstant;
  w.xSelectCallback = sqlite3SelectWalkFail;
#ifdef SQLITE_DEBUG
  w.xSelectCallback2 = sqlite3SelectWalkAssert2;
#endif
  w.u.iCur = iCur;
  sqlite3WalkExpr(&w, p);
  return w.eCode;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movw $0x1, 0x24(%rsp)
leaq 0x9d0c(%rip), %rax      # 0x2c0987
movq %rax, 0x8(%rsp)
leaq 0x9df9(%rip), %rax      # 0x2c0a80
movq %rax, 0x10(%rsp)
movl $0x0, 0x28(%rsp)
testq %rdi, %rdi
je 0x2b6cad
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2c0a8c
movzwl 0x24(%rbx), %eax
jmp 0x2b6cb2
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PExprAddSelect
SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){
  if( pExpr ){
    pExpr->x.pSelect = pSelect;
    ExprSetProperty(pExpr, EP_xIsSelect|EP_Subquery);
    sqlite3ExprSetHeightAndFlags(pParse, pExpr);
  }else{
    assert( pParse->db->mallocFailed );
    sqlite3SelectDelete(pParse->db, pSelect);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2b6d11
movq %rdx, 0x20(%rsi)
orl $0x200800, 0x4(%rsi)    # imm = 0x200800
jmp 0x2b6cb8
testq %rdx, %rdx
je 0x2b6d26
movq (%rdi), %rdi
movq %rdx, %rsi
movl $0x1, %edx
jmp 0x2a62e6
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: parserAddExprIdListTerm
static ExprList *parserAddExprIdListTerm(
    Parse *pParse,
    ExprList *pPrior,
    Token *pIdToken,
    int hasCollate,
    int sortOrder
  ){
    ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0);
    if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED)
        && pParse->db->init.busy==0
    ){
      sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"",
                         pIdToken->n, pIdToken->z);
    }
    sqlite3ExprListSetName(pParse, p, pIdToken, 1);
    return p;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
xorl %edx, %edx
callq 0x2b1a3f
movq %rax, %r15
notl %ebp
orl %r12d, %ebp
je 0x2b6d72
movq (%r14), %rax
cmpb $0x0, 0xb5(%rax)
jne 0x2b6d72
movl 0x8(%rbx), %edx
movq (%rbx), %rcx
leaq 0x122213(%rip), %rsi    # 0x3d8f7b
movq %r14, %rdi
xorl %eax, %eax
callq 0x27b48d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x2b1ae1
movq %r15, %rax
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: sqlite3Vacuum
SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int iDb = 0;
  if( v==0 ) goto build_vacuum_end;
  if( pParse->nErr ) goto build_vacuum_end;
  if( pNm ){
#ifndef SQLITE_BUG_COMPATIBLE_20160819
    /* Default behavior:  Report an error if the argument to VACUUM is
    ** not recognized */
    iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
    if( iDb<0 ) goto build_vacuum_end;
#else
    /* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments
    ** to VACUUM are silently ignored.  This is a back-out of a bug fix that
    ** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270).
    ** The buggy behavior is required for binary compatibility with some
    ** legacy applications. */
    iDb = sqlite3FindDb(pParse->db, pNm);
    if( iDb<0 ) iDb = 0;
#endif
  }
  if( iDb!=1 ){
    int iIntoReg = 0;
    if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){
      iIntoReg = ++pParse->nMem;
      sqlite3ExprCode(pParse, pInto, iIntoReg);
    }
    sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
    sqlite3VdbeUsesBtree(v, iDb);
  }
build_vacuum_end:
  sqlite3ExprDelete(pParse->db, pInto);
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
callq 0x2bc630
testq %rax, %rax
je 0x2b7007
cmpl $0x0, 0x30(%r14)
je 0x2b7029
testq %rbx, %rbx
je 0x2b7017
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2a6164
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
xorl %r12d, %r12d
movl $0x0, %ebp
testq %r13, %r13
je 0x2b705b
movq %rsp, %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x2c3833
movl %eax, %ebp
testl %eax, %eax
sets %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
jne 0x2b7007
testq %rbx, %rbx
je 0x2b70ce
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %rdi
movups %xmm0, 0x20(%rdi)
xorl %r12d, %r12d
movq %r12, 0x30(%rdi)
movups %xmm0, 0x10(%rdi)
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movq %r12, 0x70(%rax)
movq %r14, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x10000, 0x28(%rdi)    # imm = 0x10000
movq %rbx, %rsi
callq 0x2c496c
testl %eax, %eax
jne 0x2b70ce
movl 0x38(%r14), %r12d
incl %r12d
movl %r12d, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x2bc7e9
movq %r15, %rdi
movl $0x8, %esi
movl %ebp, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
orl %eax, 0xc8(%r15)
cmpl $0x1, %ebp
je 0x2b7007
movq (%r15), %rcx
movq 0x20(%rcx), %rcx
movl %ebp, %edx
shlq $0x5, %rdx
movq 0x8(%rcx,%rdx), %rcx
cmpb $0x0, 0x11(%rcx)
je 0x2b7007
orl %eax, 0xcc(%r15)
jmp 0x2b7007
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3TriggerUpdateStep
SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
  Parse *pParse,          /* Parser */
  Token *pTableName,   /* Name of the table to be updated */
  SrcList *pFrom,
  ExprList *pEList,    /* The SET clause: list of column and new values */
  Expr *pWhere,        /* The WHERE clause */
  u8 orconf,           /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
  const char *zStart,  /* Start of SQL text */
  const char *zEnd     /* End of SQL text */
){
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;

  pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd);
  if( pTriggerStep ){
    if( IN_RENAME_OBJECT ){
      pTriggerStep->pExprList = pEList;
      pTriggerStep->pWhere = pWhere;
      pTriggerStep->pFrom = pFrom;
      pEList = 0;
      pWhere = 0;
      pFrom = 0;
    }else{
      pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
      pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE);
    }
    pTriggerStep->orconf = orconf;
  }
  sqlite3ExprListDelete(db, pEList);
  sqlite3ExprDelete(db, pWhere);
  sqlite3SrcListDelete(db, pFrom);
  return pTriggerStep;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rbp
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq (%rdi), %r15
movl $0x7f, %esi
callq 0x2e7ded
movq %rax, %r12
testq %rax, %rax
je 0x2baccd
cmpb $0x2, 0x11c(%rbp)
jb 0x2bac7a
movq %r13, 0x30(%r12)
movq %r14, 0x28(%r12)
xorl %r14d, %r14d
movq %rbx, %rax
xorl %r13d, %r13d
xorl %ebx, %ebx
jmp 0x2bacbf
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x2c2deb
movq %rax, 0x30(%r12)
testq %r14, %r14
je 0x2baca8
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2c2864
jmp 0x2bacaa
xorl %eax, %eax
movq %rax, 0x28(%r12)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2c30e3
movq %rax, 0x20(%r12)
movl 0x4(%rsp), %eax
movb %al, 0x1(%r12)
testq %r13, %r13
je 0x2bacdd
movq %r15, %rdi
movq %r13, %rsi
callq 0x2a65a3
testq %r14, %r14
je 0x2baced
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a6164
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a63cf
movq %r12, %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: sqlite3TriggerInsertStep
SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(
  Parse *pParse,      /* Parser */
  Token *pTableName,  /* Name of the table into which we insert */
  IdList *pColumn,    /* List of columns in pTableName to insert into */
  Select *pSelect,    /* A SELECT statement that supplies values */
  u8 orconf,          /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
  Upsert *pUpsert,    /* ON CONFLICT clauses for upsert */
  const char *zStart, /* Start of SQL text */
  const char *zEnd    /* End of SQL text */
){
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;

  assert(pSelect != 0 || db->mallocFailed);

  pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd);
  if( pTriggerStep ){
    if( IN_RENAME_OBJECT ){
      pTriggerStep->pSelect = pSelect;
      pSelect = 0;
    }else{
      pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
    }
    pTriggerStep->pIdList = pColumn;
    pTriggerStep->pUpsert = pUpsert;
    pTriggerStep->orconf = orconf;
    if( pUpsert ){
      sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget);
    }
  }else{
    testcase( pColumn );
    sqlite3IdListDelete(db, pColumn);
    testcase( pUpsert );
    sqlite3UpsertDelete(db, pUpsert);
  }
  sqlite3SelectDelete(db, pSelect);

  return pTriggerStep;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movl %r8d, 0x4(%rsp)
movq %rcx, %rbx
movq %rdx, %rbp
movq %rsi, %rdx
movq %rdi, %r13
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq (%rdi), %r14
movl $0x7d, %esi
callq 0x2e7ded
movq %rax, %r15
testq %rax, %rax
je 0x2bad59
cmpb $0x1, 0x11c(%r13)
jbe 0x2bad71
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0x2bad81
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2a6536
movq %r14, %rdi
movq %r12, %rsi
callq 0x2a95cf
jmp 0x2bada6
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2c2b4a
movq %rax, 0x10(%r15)
movq %rbp, 0x38(%r15)
movq %r12, 0x40(%r15)
movl 0x4(%rsp), %eax
movb %al, 0x1(%r15)
testq %r12, %r12
je 0x2bada6
movq (%r12), %rsi
movq %r13, %rdi
callq 0x2c9bfa
testq %rbx, %rbx
je 0x2badbb
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2a62e6
movq %r15, %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: sqlite3TriggerDeleteStep
SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(
  Parse *pParse,          /* Parser */
  Token *pTableName,      /* The table from which rows are deleted */
  Expr *pWhere,           /* The WHERE clause */
  const char *zStart,     /* Start of SQL text */
  const char *zEnd        /* End of SQL text */
){
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;

  pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd);
  if( pTriggerStep ){
    if( IN_RENAME_OBJECT ){
      pTriggerStep->pWhere = pWhere;
      pWhere = 0;
    }else{
      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
    }
    pTriggerStep->orconf = OE_Default;
  }
  sqlite3ExprDelete(db, pWhere);
  return pTriggerStep;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r12
movq (%rdi), %r14
movl $0x7e, %esi
callq 0x2e7ded
movq %rax, %r15
testq %rax, %rax
je 0x2bae29
cmpb $0x1, 0x11c(%r12)
jbe 0x2bae05
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0x2bae20
testq %rbx, %rbx
je 0x2bae1e
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2c2864
jmp 0x2bae20
xorl %eax, %eax
movq %rax, 0x28(%r15)
movb $0xb, 0x1(%r15)
testq %rbx, %rbx
je 0x2bae39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a6164
movq %r15, %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: sqlite3TriggerSelectStep
SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(
  sqlite3 *db,                /* Database connection */
  Select *pSelect,            /* The SELECT statement */
  const char *zStart,         /* Start of SQL text */
  const char *zEnd            /* End of SQL text */
){
  TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
  if( pTriggerStep==0 ) {
    sqlite3SelectDelete(db, pSelect);
    return 0;
  }
  pTriggerStep->op = TK_SELECT;
  pTriggerStep->pSelect = pSelect;
  pTriggerStep->orconf = OE_Default;
  pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
  return pTriggerStep;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movl $0x60, %esi
callq 0x279b27
movq %rax, %rbx
testq %rax, %rax
je 0x2bae8c
movw $0xb88, (%rbx)          # imm = 0xB88
movq %r15, 0x10(%rbx)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2e7e92
movq %rax, 0x48(%rbx)
jmp 0x2baea1
testq %r15, %r15
je 0x2baea1
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2a62e6
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: sqlite3WindowChain
SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){
  if( pWin->zBase ){
    sqlite3 *db = pParse->db;
    Window *pExist = windowFind(pParse, pList, pWin->zBase);
    if( pExist ){
      const char *zErr = 0;
      /* Check for errors */
      if( pWin->pPartition ){
        zErr = "PARTITION clause";
      }else if( pExist->pOrderBy && pWin->pOrderBy ){
        zErr = "ORDER BY clause";
      }else if( pExist->bImplicitFrame==0 ){
        zErr = "frame specification";
      }
      if( zErr ){
        sqlite3ErrorMsg(pParse,
            "cannot override %s of window: %s", zErr, pWin->zBase
        );
      }else{
        pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0);
        if( pExist->pOrderBy ){
          assert( pWin->pOrderBy==0 );
          pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0);
        }
        sqlite3DbFree(db, pWin->zBase);
        pWin->zBase = 0;
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2bc479
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2c6e1d
testq %rax, %rax
je 0x2bc479
cmpq $0x0, 0x10(%rbx)
je 0x2bc413
leaq 0x11db04(%rip), %rdx    # 0x3d9ef7
movq 0x8(%rbx), %rcx
leaq 0x11db0a(%rip), %rsi    # 0x3d9f08
movq %r15, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x27b48d
movq %rax, %r12
cmpq $0x0, 0x18(%rax)
je 0x2bc42d
cmpq $0x0, 0x18(%rbx)
je 0x2bc42d
leaq 0x11bc32(%rip), %rdx    # 0x3d805d
jmp 0x2bc3f3
cmpb $0x0, 0x23(%r12)
je 0x2bc485
movq 0x10(%r12), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2c2deb
movq %rax, 0x10(%rbx)
movq 0x18(%r12), %rsi
testq %rsi, %rsi
je 0x2bc460
movq %r14, %rdi
xorl %edx, %edx
callq 0x2c2deb
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2bc471
movq %r14, %rdi
callq 0x282904
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x11daa9(%rip), %rdx    # 0x3d9f35
jmp 0x2bc3f3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowAssemble
SQLITE_PRIVATE Window *sqlite3WindowAssemble(
  Parse *pParse,
  Window *pWin,
  ExprList *pPartition,
  ExprList *pOrderBy,
  Token *pBase
){
  if( pWin ){
    pWin->pPartition = pPartition;
    pWin->pOrderBy = pOrderBy;
    if( pBase ){
      pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n);
    }
  }else{
    sqlite3ExprListDelete(pParse->db, pPartition);
    sqlite3ExprListDelete(pParse->db, pOrderBy);
  }
  return pWin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x2bc4ea
movq %rdx, 0x10(%rbx)
movq %r15, 0x18(%rbx)
testq %r8, %r8
je 0x2bc513
movq (%r8), %r15
testq %r15, %r15
je 0x2bc50c
movl 0x8(%r8), %r12d
movq (%r14), %rdi
leaq 0x1(%r12), %rsi
callq 0x282a35
testq %rax, %rax
je 0x2bc50c
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x17660
movb $0x0, (%r14,%r12)
jmp 0x2bc50f
testq %rdx, %rdx
je 0x2bc4fa
movq (%r14), %rdi
movq %rdx, %rsi
callq 0x2a65a3
testq %r15, %r15
je 0x2bc513
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2a65a3
jmp 0x2bc513
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
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: sqlite3GetVdbe
SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
  if( pParse->pVdbe ){
    return pParse->pVdbe;
  }
  if( pParse->pToplevel==0
   && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
  ){
    pParse->okConstFactor = 1;
  }
  return sqlite3VdbeCreate(pParse);
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2bc63a
retq
cmpq $0x0, 0xa0(%rdi)
jne 0x27b5ee
movq (%rdi), %rax
testb $0x8, 0x5c(%rax)
jne 0x27b5ee
movb $0x1, 0x23(%rdi)
jmp 0x27b5ee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeTableLocks
static void codeTableLocks(Parse *pParse){
  int i;
  Vdbe *pVdbe;

  pVdbe = sqlite3GetVdbe(pParse);
  assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */

  for(i=0; i<pParse->nTableLock; i++){
    TableLock *p = &pParse->aTableLock[i];
    int p1 = p->iDb;
    sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
                      p->zLockName, P4_STATIC);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x2bc630
cmpl $0x0, 0x88(%rbx)
jle 0x2bc6d1
movq %rax, %r14
movl $0x10, %r12d
xorl %r13d, %r13d
movq 0x90(%rbx), %rax
movl -0x10(%rax,%r12), %edx
movl -0xc(%rax,%r12), %ecx
movzbl -0x8(%rax,%r12), %r8d
movq (%rax,%r12), %r15
movq %r14, %rdi
movl $0xa1, %esi
callq 0x2a83e1
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x27b778
incq %r13
movslq 0x88(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x2bc684
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: sqlite3ExprCode
SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
  int inReg;

  assert( pExpr==0 || !ExprHasVVAProperty(pExpr,EP_Immutable) );
  assert( target>0 && target<=pParse->nMem );
  assert( pParse->pVdbe!=0 || pParse->db->mallocFailed );
  if( pParse->pVdbe==0 ) return;
  inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
  if( inReg!=target ){
    u8 op;
    if( ExprHasProperty(pExpr,EP_Subquery) ){
      op = OP_Copy;
    }else{
      op = OP_SCopy;
    }
    sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x2bc806
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x2bcc6c
cmpl %ebx, %eax
jne 0x2bc80c
popq %rbx
popq %r14
popq %r15
retq
btl $0x15, 0x4(%r15)
movl $0x4d, %esi
sbbl $-0x1, %esi
movq 0x10(%r14), %rdi
movl %eax, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x2a83e1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3TableLock
SQLITE_PRIVATE void sqlite3TableLock(
  Parse *pParse,     /* Parsing context */
  int iDb,           /* Index of the database containing the table to lock */
  Pgno iTab,         /* Root page number of the table to be locked */
  u8 isWriteLock,    /* True for a write lock */
  const char *zName  /* Name of the table to be locked */
){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  int i;
  int nBytes;
  TableLock *p;
  assert( iDb>=0 );

  if( iDb==1 ) return;
  if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
  for(i=0; i<pToplevel->nTableLock; i++){
    p = &pToplevel->aTableLock[i];
    if( p->iDb==iDb && p->iTab==iTab ){
      p->isWriteLock = (p->isWriteLock || isWriteLock);
      return;
    }
  }

  nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
  pToplevel->aTableLock =
      sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
  if( pToplevel->aTableLock ){
    p = &pToplevel->aTableLock[pToplevel->nTableLock++];
    p->iDb = iDb;
    p->iTab = iTab;
    p->isWriteLock = isWriteLock;
    p->zLockName = zName;
  }else{
    pToplevel->nTableLock = 0;
    sqlite3OomFault(pToplevel->db);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xa0(%rdi), %r12
testq %r12, %r12
cmoveq %rdi, %r12
cmpl $0x1, %esi
je 0x2bca28
movl %ecx, %ebx
movl %esi, %r15d
movq (%rdi), %rax
movq 0x20(%rax), %rax
movslq %esi, %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rax
cmpb $0x0, 0x11(%rax)
je 0x2bca28
movq %r8, %r14
movl %edx, %ebp
movslq 0x88(%r12), %rax
movq 0x90(%r12), %rsi
testq %rax, %rax
jle 0x2bc9b5
leaq (,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rdx
xorl %ecx, %ecx
cmpl %r15d, (%rsi,%rcx)
jne 0x2bc9ac
cmpl %ebp, 0x4(%rsi,%rcx)
je 0x2bca1f
addq $0x18, %rcx
cmpq %rcx, %rdx
jne 0x2bc9a0
leal (%rax,%rax,2), %eax
leal 0x18(,%rax,8), %eax
movq (%r12), %rdi
movslq %eax, %rdx
callq 0x2919d2
movq %rax, 0x90(%r12)
testq %rax, %rax
je 0x2bca02
movslq 0x88(%r12), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x88(%r12)
leaq (%rcx,%rcx,2), %rcx
movl %r15d, (%rax,%rcx,8)
movl %ebp, 0x4(%rax,%rcx,8)
movb %bl, 0x8(%rax,%rcx,8)
movq %r14, 0x10(%rax,%rcx,8)
jmp 0x2bca28
movl $0x0, 0x88(%r12)
movq (%r12), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x278b1c
orb 0x8(%rsi,%rcx), %bl
setne 0x8(%rsi,%rcx)
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: sqlite3VdbeSetP4KeyInfo
SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
  Vdbe *v = pParse->pVdbe;
  KeyInfo *pKeyInfo;
  assert( v!=0 );
  assert( pIdx!=0 );
  pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
  if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
callq 0x2bca75
testq %rax, %rax
je 0x2bca73
movq (%rbx), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2bca57
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
movq %rax, %rdx
popq %rbx
jmp 0x28fb69
movq 0x88(%rbx), %rcx
movslq 0x90(%rbx), %rdx
leaq (%rdx,%rdx,2), %rdx
movb $-0x9, -0x17(%rcx,%rdx,8)
movq %rax, -0x8(%rcx,%rdx,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3KeyInfoOfIndex
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
  int i;
  int nCol = pIdx->nColumn;
  int nKey = pIdx->nKeyCol;
  KeyInfo *pKey;
  if( pParse->nErr ) return 0;
  if( pIdx->uniqNotNull ){
    pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
  }else{
    pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
  }
  if( pKey ){
    assert( sqlite3KeyInfoIsWriteable(pKey) );
    for(i=0; i<nCol; i++){
      const char *zColl = pIdx->azColl[i];
      pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
                        sqlite3LocateCollSeq(pParse, zColl);
      pKey->aSortFlags[i] = pIdx->aSortOrder[i];
      assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
    }
    if( pParse->nErr ){
      assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
      if( pIdx->bNoQuery==0 ){
        /* Deactivate the index because it contains an unknown collating
        ** sequence.  The only way to reactive the index is to reload the
        ** schema.  Adding the missing collating sequence later does not
        ** reactive the index.  The application had the chance to register
        ** the missing index using the collation-needed callback.  For
        ** simplicity, SQLite will not give the application a second chance.
        */
        pIdx->bNoQuery = 1;
        pParse->rc = SQLITE_ERROR_RETRY;
      }
      sqlite3KeyInfoUnref(pKey);
      pKey = 0;
    }
  }
  return pKey;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x30(%rdi)
je 0x2bca9a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq %rdi, %r14
movzwl 0x60(%rsi), %ebp
testb $0x8, 0x63(%rsi)
movq (%rdi), %rdi
jne 0x2bcab3
movl %ebp, %esi
xorl %edx, %edx
jmp 0x2bcabc
movzwl 0x5e(%r15), %esi
movl %ebp, %edx
subl %esi, %edx
callq 0x2bcb86
movq %rax, %rbx
testq %rax, %rax
je 0x2bca86
testl %ebp, %ebp
je 0x2bcb10
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x115086(%rip), %rbp    # 0x3d1b60
movq 0x40(%r15), %rax
movq (%rax,%r13,8), %rsi
cmpq %rbp, %rsi
je 0x2bcaf1
movq %r14, %rdi
callq 0x2bcc04
jmp 0x2bcaf3
xorl %eax, %eax
movq %rax, 0x20(%rbx,%r13,8)
movq 0x38(%r15), %rax
movb (%rax,%r13), %al
movq 0x18(%rbx), %rcx
movb %al, (%rcx,%r13)
incq %r13
cmpq %r13, %r12
jne 0x2bcada
cmpl $0x0, 0x30(%r14)
je 0x2bca88
movzwl 0x63(%r15), %eax
btl $0x8, %eax
jb 0x2bcb38
orl $0x100, %eax            # imm = 0x100
movw %ax, 0x63(%r15)
movl $0x201, 0x18(%r14)      # imm = 0x201
decl (%rbx)
jne 0x2bca86
movq 0x10(%rbx), %rdi
movq %rbx, %rsi
callq 0x282904
jmp 0x2bca86
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeAppendP4
SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe *p, void *pP4, int n){
  VdbeOp *pOp;
  assert( n!=P4_INT32 && n!=P4_VTAB );
  assert( n<=0 );
  if( p->db->mallocFailed ){
    freeP4(p->db, n, pP4);
  }else{
    assert( pP4!=0 );
    assert( p->nOp>0 );
    pOp = &p->aOp[p->nOp-1];
    assert( pOp->p4type==P4_NOTUSED );
    pOp->p4type = n;
    pOp->p4.p = pP4;
  }
}

// Assembly:
movq %rsi, %rax
movq (%rdi), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2bcb6a
movq %rcx, %rdi
movl %edx, %esi
movq %rax, %rdx
jmp 0x28fb69
movq 0x88(%rdi), %rcx
movslq 0x90(%rdi), %rsi
leaq (%rsi,%rsi,2), %rsi
movb %dl, -0x17(%rcx,%rsi,8)
movq %rax, -0x8(%rcx,%rsi,8)
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3KeyInfoAlloc
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
  int nExtra = (N+X)*(sizeof(CollSeq*)+1) - sizeof(CollSeq*);
  KeyInfo *p = sqlite3DbMallocRawNN(db, sizeof(KeyInfo) + nExtra);
  if( p ){
    p->aSortFlags = (u8*)&p->aColl[N+X];
    p->nKeyField = (u16)N;
    p->nAllField = (u16)(N+X);
    p->enc = ENC(db);
    p->db = db;
    p->nRef = 1;
    memset(&p[1], 0, nExtra);
  }else{
    sqlite3OomFault(db);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
addl %esi, %r12d
leal (%r12,%r12,8), %eax
addl $-0x8, %eax
movslq %eax, %r15
leaq 0x28(%r15), %rsi
callq 0x282a35
movq %rax, %rbx
testq %rax, %rax
je 0x2bcbf0
movslq %r12d, %rax
leaq (%rbx,%rax,8), %rax
addq $0x20, %rax
movq %rax, 0x18(%rbx)
movw %bp, 0x6(%rbx)
movw %r12w, 0x8(%rbx)
movb 0x5e(%r14), %al
movb %al, 0x4(%rbx)
movq %r14, 0x10(%rbx)
movl $0x1, (%rbx)
movq %rbx, %rdi
addq $0x28, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x173a0
jmp 0x2bcbf8
movq %r14, %rdi
callq 0x278b1c
movq %rbx, %rax
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: sqlite3TableColumnToStorage
SQLITE_PRIVATE i16 sqlite3TableColumnToStorage(Table *pTab, i16 iCol){
  int i;
  i16 n;
  assert( iCol<pTab->nCol );
  if( (pTab->tabFlags & TF_HasVirtual)==0 || iCol<0 ) return iCol;
  for(i=0, n=0; i<iCol; i++){
    if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ) n++;
  }
  if( pTab->aCol[i].colFlags & COLFLAG_VIRTUAL ){
    /* iCol is a virtual column itself */
    return pTab->nNVCol + i - n;
  }else{
    /* iCol is a normal or stored column */
    return n;
  }
}

// Assembly:
movl %esi, %eax
testw %ax, %ax
js 0x2be0e8
movl 0x40(%rdi), %ecx
andl $0x20, %ecx
je 0x2be0e8
movq 0x8(%rdi), %rcx
movl %eax, %edx
testw %ax, %ax
je 0x2be0d9
movq %rdx, %r8
shlq $0x5, %r8
xorl %r9d, %r9d
xorl %esi, %esi
movb 0x1c(%rcx,%r9), %r10b
andb $0x20, %r10b
cmpb $0x1, %r10b
adcw $0x0, %si
addq $0x20, %r9
cmpq %r9, %r8
jne 0x2be0bd
jmp 0x2be0db
xorl %esi, %esi
shlq $0x5, %rdx
testb $0x20, 0x1c(%rcx,%rdx)
jne 0x2be0e9
movl %esi, %eax
retq
subl %esi, %eax
addw 0x48(%rdi), %ax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCodeGeneratedColumn
SQLITE_PRIVATE void sqlite3ExprCodeGeneratedColumn(
  Parse *pParse,
  Column *pCol,
  int regOut
){
  int iAddr;
  Vdbe *v = pParse->pVdbe;
  assert( v!=0 );
  assert( pParse->iSelfTab!=0 );
  if( pParse->iSelfTab>0 ){
    iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut);
  }else{
    iAddr = 0;
  }
  sqlite3ExprCodeCopy(pParse, pCol->pDflt, regOut);
  if( pCol->affinity>=SQLITE_AFF_TEXT ){
    sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1);
  }
  if( iAddr ) sqlite3VdbeJumpHere(v, iAddr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
movq 0x10(%rdi), %rbx
movl 0x40(%rdi), %edx
testl %edx, %edx
jle 0x2be124
decl %edx
movq %rbx, %rdi
movl $0x15, %esi
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x2a83e1
movl %eax, %ebp
jmp 0x2be126
xorl %ebp, %ebp
movq 0x8(%r14), %rsi
movq %r12, %rdi
movl %r15d, %edx
callq 0x2c00af
cmpb $0x42, 0x19(%r14)
jl 0x2be16a
addq $0x19, %r14
movq %rbx, %rdi
movl $0x5a, %esi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x27b778
testl %ebp, %ebp
je 0x2be1a3
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2be186
leaq 0x200d04(%rip), %rcx    # 0x4bee88
jmp 0x2be1a0
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)
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: sqlite3ExprCodeGetColumn
SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(
  Parse *pParse,   /* Parsing and code generating context */
  Table *pTab,     /* Description of the table we are reading from */
  int iColumn,     /* Index of the table column */
  int iTable,      /* The cursor pointing to the table */
  int iReg,        /* Store results here */
  u8 p5            /* P5 value for OP_Column + FLAGS */
){
  assert( pParse->pVdbe!=0 );
  sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg);
  if( p5 ){
    VdbeOp *pOp = sqlite3VdbeGetOp(pParse->pVdbe,-1);
    if( pOp->opcode==OP_Column ) pOp->p5 = p5;
  }
  return iReg;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r9d, %ebp
movl %r8d, %ebx
movl %edx, %eax
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %ecx, %edx
movl %eax, %ecx
callq 0x2c010f
testl %ebp, %ebp
je 0x2be209
movq 0x10(%r14), %rax
movq (%rax), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2be1e2
leaq 0x200ca8(%rip), %rax    # 0x4bee88
jmp 0x2be1fc
movslq 0x90(%rax), %rcx
movq 0x88(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x18, %rax
cmpb $0x59, (%rax)
jne 0x2be209
movzbl %bpl, %ecx
movw %cx, 0x2(%rax)
movl %ebx, %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: codeInteger
static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
  Vdbe *v = pParse->pVdbe;
  if( pExpr->flags & EP_IntValue ){
    int i = pExpr->u.iValue;
    assert( i>=0 );
    if( negFlag ) i = -i;
    sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
  }else{
    int c;
    i64 value;
    const char *z = pExpr->u.zToken;
    assert( z!=0 );
    c = sqlite3DecOrHexToI64(z, &value);
    if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){
#ifdef SQLITE_OMIT_FLOATING_POINT
      sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
#else
#ifndef SQLITE_OMIT_HEX_INTEGER
      if( sqlite3_strnicmp(z,"0x",2)==0 ){
        sqlite3ErrorMsg(pParse, "hex literal too big: %s%s", negFlag?"-":"",z);
      }else
#endif
      {
        codeReal(v, z, negFlag, iMem);
      }
#endif
    }else{
      if( negFlag ){ value = c==3 ? SMALLEST_INT64 : -value; }
      sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq 0x10(%rdi), %r14
testb $0x4, 0x5(%rsi)
jne 0x2be2b6
movq %rdi, %r15
movq 0x8(%rsi), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x282453
movl %eax, %ecx
xorl $0x3, %ecx
orl %ebp, %ecx
setne %cl
cmpl $0x2, %eax
je 0x2be26f
testb %cl, %cl
je 0x2be26f
testl %ebp, %ebp
setne %dl
movq 0x8(%rsp), %rcx
negq %rcx
seto %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x2be2e0
testq %r12, %r12
je 0x2be367
xorl %ecx, %ecx
leaq 0x11305f(%rip), %rax    # 0x3d12e0
leaq 0x119385(%rip), %rdx    # 0x3d760d
movzbl (%r12,%rcx), %esi
testq %rsi, %rsi
je 0x2be321
movzbl (%rsi,%rax), %esi
movzbl (%rcx,%rdx), %edi
movb (%rdi,%rax), %dil
cmpb %dil, %sil
jne 0x2be32b
incq %rcx
cmpq $0x2, %rcx
jne 0x2be288
jmp 0x2be333
movl 0x8(%rsi), %eax
movl %eax, %edx
negl %edx
testl %ebp, %ebp
cmovel %eax, %edx
movq %r14, %rdi
movl $0x45, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a83e1
testl %ebp, %ebp
je 0x2be2fa
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
cmpl $0x3, %eax
cmoveq %rdx, %rcx
movq %rcx, 0x8(%rsp)
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movl $0x46, %esi
movl %ebx, %edx
movl $0xfffffff2, %r8d       # imm = 0xFFFFFFF2
callq 0x2c0763
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl (%rcx,%rdx), %ecx
movb (%rcx,%rax), %dil
xorl %esi, %esi
movzbl %dil, %eax
cmpl %eax, %esi
jne 0x2be367
testl %ebp, %ebp
leaq 0x109a6e(%rip), %rax    # 0x3c7daa
leaq 0x10be2d(%rip), %rdx    # 0x3ca170
cmovneq %rax, %rdx
leaq 0x1192c2(%rip), %rsi    # 0x3d7610
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27b48d
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ebx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2be37f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeReal
static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
  if( ALWAYS(z!=0) ){
    double value;
    sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
    assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
    if( negateFlag ) value = -value;
    sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2be3ea
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movq %rsp, %rsi
movq %r15, %rdi
movl %eax, %edx
movl $0x1, %ecx
callq 0x292288
testl %ebp, %ebp
je 0x2be3c8
movsd (%rsp), %xmm0
xorps 0x9168c(%rip), %xmm0    # 0x34fa50
movlps %xmm0, (%rsp)
movq %rsp, %rcx
movq %r14, %rdi
movl $0x96, %esi
movl %ebx, %edx
movl $0xfffffff3, %r8d       # imm = 0xFFFFFFF3
callq 0x2c0763
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: sqlite3ExprCodeTemp
SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
  int r2;
  pExpr = sqlite3ExprSkipCollateAndLikely(pExpr);
  if( ConstFactorOk(pParse)
   && pExpr->op!=TK_REGISTER
   && sqlite3ExprIsConstantNotJoin(pExpr)
  ){
    *pReg  = 0;
    r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
  }else{
    int r1 = sqlite3GetTempReg(pParse);
    r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
    if( r2==r1 ){
      *pReg = r1;
    }else{
      sqlite3ReleaseTempReg(pParse, r1);
      *pReg = 0;
    }
  }
  return r2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x2be615
movq %rsi, %r15
movl 0x4(%r15), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2be618
btl $0x12, %eax
jb 0x2be605
addq $0x10, %r15
jmp 0x2be60d
movq 0x20(%r15), %r15
addq $0x8, %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x2be5ee
xorl %r15d, %r15d
cmpb $0x0, 0x23(%r14)
je 0x2be67d
cmpb $-0x53, (%r15)
je 0x2be67d
movq %rsp, %r12
movw $0x2, 0x24(%r12)
leaq 0x2350(%rip), %rax      # 0x2c0987
movq %rax, 0x8(%r12)
leaq 0x243d(%rip), %rax      # 0x2c0a80
movq %rax, 0x10(%r12)
movl $0x0, 0x28(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2c0a8c
cmpw $0x0, 0x24(%r12)
je 0x2be67d
movl $0x0, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2be7a4
jmp 0x2be6d9
movb 0x1f(%r14), %al
testb %al, %al
je 0x2be698
decb %al
movb %al, 0x1f(%r14)
movzbl %al, %eax
movl 0xd4(%r14,%rax,4), %ebp
jmp 0x2be6a2
movl 0x38(%r14), %ebp
incl %ebp
movl %ebp, 0x38(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2bcc6c
cmpl %ebp, %eax
jne 0x2be6b7
movl %ebp, %ecx
jmp 0x2be6d7
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x2be6d7
movzbl 0x1f(%r14), %edx
cmpq $0x7, %rdx
ja 0x2be6d7
leal 0x1(%rdx), %esi
movb %sil, 0x1f(%r14)
movl %ebp, 0xd4(%r14,%rdx,4)
movl %ecx, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq