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: 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 0x2bb38d
testq %rax, %rax
je 0x2c028d
movq %rax, %rbx
testq %r14, %r14
je 0x2c026f
movl (%r14), %eax
movq (%r15), %rcx
cmpl 0x94(%rcx), %eax
jle 0x2c026f
leaq 0x12241d(%rip), %rsi    # 0x3e267f
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x284eb8
movq %r14, 0x20(%rbx)
orb $0x4, 0x4(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2c0490
cmpl $0x1, %ebp
jne 0x2c029f
orb $0x2, 0x4(%rbx)
jmp 0x2c029f
testq %r14, %r14
je 0x2c029d
movq %r13, %rdi
movq %r14, %rsi
callq 0x2b0183
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c02d7
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 0x2c02d6
cmpb $-0x5d, 0x20(%rdx)
jne 0x2c02e2
retq
movq (%rdi), %rdi
movq %rdx, %rsi
jmp 0x2afe06
leaq 0x1223b8(%rip), %rsi    # 0x3e26a1
xorl %eax, %eax
jmp 0x284eb8
// File: /workspace/github_c_makefile_star2_O1/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 0x2c038a
movq %rsi, %rdx
testq %rbx, %rbx
je 0x2c0347
movq (%rdi), %r14
movl $0x20000001, %eax       # imm = 0x20000001
movl 0x4(%rdx), %ecx
andl %eax, %ecx
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x2c032a
andl 0x4(%rbx), %eax
cmpl $0x20000000, %eax       # imm = 0x20000000
jne 0x2c0333
cmpb $0x1, 0x11c(%rdi)
jbe 0x2c034c
movl $0x2c, %esi
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x2b6fa0
movq %rdx, %rbx
jmp 0x2c038a
movq %r14, %rdi
movq %rdx, %rsi
callq 0x2afd54
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2afd54
leaq 0xb78e4(%rip), %rax     # 0x377c4d
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rdx)
movq %r14, %rdi
movl $0x98, %esi
xorl %ecx, %ecx
callq 0x2bb38d
movq %rax, %rbx
movq %rbx, %rax
addq $0x18, %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: 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 0x2c03d2
cmpb $0x77, (%rsi)
jne 0x2c03d2
cmpb $0x1, 0x11c(%rdi)
ja 0x2c03d2
movq (%rdi), %rdi
movb %cl, (%rbx)
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2c03ca
callq 0x2afd54
movq $0x0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c0448
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x11c(%rdi), %bpl
cmpb $0x2, %bpl
jb 0x2c0435
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movq %r14, (%rdi)
leaq 0x12ddf(%rip), %rax     # 0x2d31ee
movq %rax, 0x8(%rdi)
leaq 0x12df8(%rip), %rax     # 0x2d3212
movq %rax, 0x10(%rdi)
movb $0x3, 0x11c(%r14)
movq %rbx, %rsi
callq 0x2ca211
movb %bpl, 0x11c(%r14)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2afd54
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c04e9
movq %rdx, 0x20(%rsi)
orl $0x200800, 0x4(%rsi)    # imm = 0x200800
jmp 0x2c0490
testq %rdx, %rdx
je 0x2c04fe
movq (%rdi), %rdi
movq %rdx, %rsi
movl $0x1, %edx
jmp 0x2afecb
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %edx, %edx
callq 0x2bb1a3
movq %rax, %r15
notl %ebp
orl %r12d, %ebp
je 0x2c0547
movq (%r14), %rax
cmpb $0x0, 0xb5(%rax)
jne 0x2c0547
movl 0x8(%rbx), %edx
movq (%rbx), %rcx
leaq 0x122193(%rip), %rsi    # 0x3e26d0
movq %r14, %rdi
xorl %eax, %eax
callq 0x284eb8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x2bb245
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
callq 0x2c5ddf
testq %rax, %rax
je 0x2c0786
cmpl $0x0, 0x30(%r14)
je 0x2c07a8
testq %rbx, %rbx
je 0x2c0796
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2afd54
addq $0xc8, %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 0x2c07dc
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x2ccf63
movl %eax, %ebp
testl %eax, %eax
sets %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
jne 0x2c0786
testq %rbx, %rbx
je 0x2c0852
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x20(%rdi)
xorl %r12d, %r12d
movq %r12, 0x30(%rdi)
movaps %xmm0, 0x10(%rdi)
leaq 0x50(%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 0x2ce0ea
testl %eax, %eax
jne 0x2c0852
movl 0x38(%r14), %r12d
incl %r12d
movl %r12d, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x2c5f97
movq %r15, %rdi
movl $0x8, %esi
movl %ebp, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
orl %eax, 0xc8(%r15)
cmpl $0x1, %ebp
je 0x2c0786
movq (%r15), %rcx
movq 0x20(%rcx), %rcx
movslq %ebp, %rdx
shlq $0x5, %rdx
movq 0x8(%rcx,%rdx), %rcx
cmpb $0x0, 0x11(%rcx)
je 0x2c0786
orl %eax, 0xcc(%r15)
jmp 0x2c0786
// File: /workspace/github_c_makefile_star2_O1/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 0x2f1096
movq %rax, %r12
testq %rax, %rax
je 0x2c4412
cmpb $0x2, 0x11c(%rbp)
jb 0x2c43bf
movq %r13, 0x30(%r12)
movq %r14, 0x28(%r12)
xorl %r14d, %r14d
movq %rbx, %rax
xorl %r13d, %r13d
xorl %ebx, %ebx
jmp 0x2c4404
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x2cc525
movq %rax, 0x30(%r12)
testq %r14, %r14
je 0x2c43ed
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2cbf97
jmp 0x2c43ef
xorl %eax, %eax
movq %rax, 0x28(%r12)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2cc81d
movq %rax, 0x20(%r12)
movl 0x4(%rsp), %eax
movb %al, 0x1(%r12)
testq %r13, %r13
je 0x2c4422
movq %r15, %rdi
movq %r13, %rsi
callq 0x2b0183
testq %r14, %r14
je 0x2c4432
movq %r15, %rdi
movq %r14, %rsi
callq 0x2afd54
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2affb4
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_O1/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 0x2f1096
movq %rax, %r15
testq %rax, %rax
je 0x2c449e
cmpb $0x1, 0x11c(%r13)
jbe 0x2c44b6
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0x2c44c6
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2b0119
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b31f7
jmp 0x2c44eb
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2cc285
movq %rax, 0x10(%r15)
movq %rbp, 0x38(%r15)
movq %r12, 0x40(%r15)
movl 0x4(%rsp), %eax
movb %al, 0x1(%r15)
testq %r12, %r12
je 0x2c44eb
movq (%r12), %rsi
movq %r13, %rdi
callq 0x2d34a4
testq %rbx, %rbx
je 0x2c4500
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2afecb
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_O1/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 0x2f1096
movq %rax, %r15
testq %rax, %rax
je 0x2c456e
cmpb $0x1, 0x11c(%r12)
jbe 0x2c454a
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0x2c4565
testq %rbx, %rbx
je 0x2c4563
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2cbf97
jmp 0x2c4565
xorl %eax, %eax
movq %rax, 0x28(%r15)
movb $0xb, 0x1(%r15)
testq %rbx, %rbx
je 0x2c457e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2afd54
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x283569
testq %rax, %rax
je 0x2c45d1
movq %rax, %rbx
movw $0xb88, (%rax)          # imm = 0xB88
movq %r15, 0x10(%rax)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2f113b
movq %rax, 0x48(%rbx)
jmp 0x2c45e8
testq %r15, %r15
je 0x2c45e6
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2afecb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c5c11
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2d0492
testq %rax, %rax
je 0x2c5c11
movq %rax, %r12
cmpq $0x0, 0x10(%rbx)
je 0x2c5b9b
leaq 0x11dab5(%rip), %rdx    # 0x3e364c
xorl %eax, %eax
jmp 0x2c5bc9
cmpq $0x0, 0x18(%r12)
je 0x2c5bb3
cmpq $0x0, 0x18(%rbx)
je 0x2c5bb3
leaq 0x11bc01(%rip), %rdx    # 0x3e17b2
jmp 0x2c5b97
xorl %edx, %edx
cmpb $0x0, 0x23(%r12)
setne %al
leaq 0x11dac5(%rip), %rcx    # 0x3e368a
cmoveq %rcx, %rdx
testb %al, %al
je 0x2c5c1d
movq 0x10(%r12), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2cc525
movq %rax, 0x10(%rbx)
movq 0x18(%r12), %rsi
testq %rsi, %rsi
je 0x2c5bf8
movq %r14, %rdi
xorl %edx, %edx
callq 0x2cc525
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2c5c09
movq %r14, %rdi
callq 0x28c3e7
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rcx
leaq 0x11da35(%rip), %rsi    # 0x3e365d
movq %r15, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x284eb8
// File: /workspace/github_c_makefile_star2_O1/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 0x2c5c7d
movq %rdx, 0x10(%rbx)
movq %r15, 0x18(%rbx)
testq %r8, %r8
je 0x2c5cbe
movq (%r8), %r12
movl 0x8(%r8), %r15d
testq %r12, %r12
je 0x2c5c9f
movq (%r14), %rdi
leaq 0x1(%r15), %rsi
callq 0x28c518
movq %rax, %r14
jmp 0x2c5ca2
testq %rdx, %rdx
je 0x2c5c8d
movq (%r14), %rdi
movq %rdx, %rsi
callq 0x2b0183
testq %r15, %r15
je 0x2c5cbe
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2b0183
jmp 0x2c5cbe
xorl %r14d, %r14d
testq %r14, %r14
je 0x2c5cba
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x17660
movb $0x0, (%r14,%r15)
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_O1/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 0x2c5de9
retq
cmpq $0x0, 0xa0(%rdi)
jne 0x285019
movq (%rdi), %rax
testb $0x8, 0x5c(%rax)
jne 0x285019
movb $0x1, 0x23(%rdi)
jmp 0x285019
// File: /workspace/github_c_makefile_star2_O1/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 0x2c5ddf
cmpl $0x0, 0x88(%rbx)
jle 0x2c5e80
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 0x2b200c
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x285198
incq %r13
movslq 0x88(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x2c5e33
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: 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 0x2c5fb4
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x2c6416
cmpl %ebx, %eax
jne 0x2c5fba
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 0x2b200c
// File: /workspace/github_c_makefile_star2_O1/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 0x2c61db
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 0x2c61db
movq %r8, %r14
movl %edx, %ebp
movslq 0x88(%r12), %rax
testq %rax, %rax
jle 0x2c6160
movq 0x90(%r12), %rcx
leaq (,%rax,8), %rdx
leaq (%rdx,%rdx,2), %rsi
xorl %edx, %edx
cmpl %r15d, (%rcx,%rdx)
jne 0x2c6157
cmpl %ebp, 0x4(%rcx,%rdx)
je 0x2c61d2
addq $0x18, %rdx
cmpq %rdx, %rsi
jne 0x2c614b
leal (%rax,%rax,2), %eax
leal 0x18(,%rax,8), %eax
movq (%r12), %rdi
movq 0x90(%r12), %rsi
movslq %eax, %rdx
callq 0x29b6a6
movq %rax, 0x90(%r12)
testq %rax, %rax
je 0x2c61b5
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 0x2c61db
movl $0x0, 0x88(%r12)
movq (%r12), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2824bb
orb 0x8(%rcx,%rdx), %bl
setne 0x8(%rcx,%rdx)
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: 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 0x2c6228
testq %rax, %rax
je 0x2c6226
movq (%rbx), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2c620a
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
movq %rax, %rdx
popq %rbx
jmp 0x29991d
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_O1/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 0x2c624d
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 0x2c6266
movl %ebp, %esi
xorl %edx, %edx
jmp 0x2c626f
movzwl 0x5e(%r15), %esi
movl %ebp, %edx
subl %esi, %edx
callq 0x2c6339
movq %rax, %rbx
testq %rax, %rax
je 0x2c6239
testl %ebp, %ebp
je 0x2c62c3
movl %ebp, %r12d
xorl %r13d, %r13d
leaq 0x115053(%rip), %rbp    # 0x3db2e0
movq 0x40(%r15), %rax
movq (%rax,%r13,8), %rsi
cmpq %rbp, %rsi
je 0x2c62a4
movq %r14, %rdi
callq 0x2c63b7
jmp 0x2c62a6
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 0x2c628d
cmpl $0x0, 0x30(%r14)
je 0x2c623b
movzwl 0x63(%r15), %eax
btl $0x8, %eax
jb 0x2c62eb
orl $0x100, %eax            # imm = 0x100
movw %ax, 0x63(%r15)
movl $0x201, 0x18(%r14)      # imm = 0x201
decl (%rbx)
jne 0x2c6239
movq 0x10(%rbx), %rdi
movq %rbx, %rsi
callq 0x28c3e7
jmp 0x2c6239
// File: /workspace/github_c_makefile_star2_O1/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 0x2c631d
movq %rcx, %rdi
movl %edx, %esi
movq %rax, %rdx
jmp 0x29991d
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_O1/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 0x28c518
movq %rax, %rbx
testq %rax, %rax
je 0x2c63a3
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 0x2c63ab
movq %r14, %rdi
callq 0x2824bb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c780d
movl 0x40(%rdi), %ecx
andl $0x20, %ecx
je 0x2c780d
testw %ax, %ax
jle 0x2c77f6
movq 0x8(%rdi), %rdx
movl %eax, %esi
shlq $0x5, %rsi
xorl %r8d, %r8d
xorl %ecx, %ecx
movb 0x1c(%rdx,%r8), %r9b
andb $0x20, %r9b
cmpb $0x1, %r9b
adcw $0x0, %cx
addq $0x20, %r8
cmpq %r8, %rsi
jne 0x2c77da
jmp 0x2c77fa
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x8(%rdi), %rdx
movl %eax, %esi
shlq $0x5, %rsi
testb $0x20, 0x1c(%rdx,%rsi)
jne 0x2c780e
movl %ecx, %eax
retq
subl %ecx, %eax
addw 0x48(%rdi), %ax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c7849
decl %edx
movq %rbx, %rdi
movl $0x15, %esi
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x2b200c
movl %eax, %ebp
jmp 0x2c784b
xorl %ebp, %ebp
movq 0x8(%r14), %rsi
movq %r12, %rdi
movl %r15d, %edx
callq 0x2c9826
cmpb $0x42, 0x19(%r14)
jl 0x2c788f
addq $0x19, %r14
movq %rbx, %rdi
movl $0x5a, %esi
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x285198
testl %ebp, %ebp
je 0x2c78c8
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2c78ab
leaq 0x2025df(%rip), %rcx    # 0x4c9e88
jmp 0x2c78c5
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_O1/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 0x2c9886
testl %ebp, %ebp
je 0x2c792e
movq 0x10(%r14), %rax
movq (%rax), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2c7907
leaq 0x202583(%rip), %rax    # 0x4c9e88
jmp 0x2c7921
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 0x2c792e
movzbl %bpl, %ecx
movw %cx, 0x2(%rax)
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c79c7
movq %rdi, %r15
movq 0x8(%rsi), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x28bf8a
movl %eax, %ecx
xorl $0x3, %ecx
orl %ebp, %ecx
setne %cl
cmpl $0x2, %eax
je 0x2c7994
testb %cl, %cl
je 0x2c7994
testl %ebp, %ebp
setne %dl
movq 0x8(%rsp), %rcx
negq %rcx
seto %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x2c7a25
leaq 0x1193c7(%rip), %rsi    # 0x3e0d62
movq %r12, %rdi
movl $0x2, %edx
callq 0x27e951
testl %eax, %eax
je 0x2c79f1
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 0x2c7a66
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 0x2b200c
testl %ebp, %ebp
leaq 0x109ad8(%rip), %rax    # 0x3d14d2
leaq 0x10be8f(%rip), %rdx    # 0x3d3890
cmovneq %rax, %rdx
leaq 0x119359(%rip), %rsi    # 0x3e0d65
movq %r15, %rdi
movq %r12, %rcx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x284eb8
testl %ebp, %ebp
je 0x2c7a3f
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 0x2c9f1d
addq $0x10, %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: 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 0x2c7ad1
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 0x29bf75
testl %ebp, %ebp
je 0x2c7aaf
movsd (%rsp), %xmm0
xorps 0x90fd5(%rip), %xmm0    # 0x358a80
movlps %xmm0, (%rsp)
movq %rsp, %rcx
movq %r14, %rdi
movl $0x96, %esi
movl %ebx, %edx
movl $0xfffffff3, %r8d       # imm = 0xFFFFFFF3
callq 0x2c9f1d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprIsVector
SQLITE_PRIVATE int sqlite3ExprVectorSize(Expr *pExpr){
  u8 op = pExpr->op;
  if( op==TK_REGISTER ) op = pExpr->op2;
  if( op==TK_VECTOR ){
    return pExpr->x.pList->nExpr;
  }else if( op==TK_SELECT ){
    return pExpr->x.pSelect->pEList->nExpr;
  }else{
    return 1;
  }
}

// Assembly:
movb (%rdi), %al
cmpb $-0x53, %al
jne 0x2c7cb8
movb 0x2(%rdi), %al
cmpb $-0x52, %al
je 0x2c7ccd
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x88, %ecx
jne 0x2c7cd9
movq 0x20(%rdi), %rdi
movq 0x20(%rdi), %rcx
xorl %eax, %eax
cmpl $0x2, (%rcx)
setge %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x2c7d1b
movl 0x4(%r15), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x2c7d1b
btl $0x12, %eax
jb 0x2c7d0b
addq $0x10, %r15
jmp 0x2c7d13
movq 0x20(%r15), %r15
addq $0x8, %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x2c7cf4
cmpb $0x0, 0x23(%r14)
je 0x2c7d80
cmpb $-0x53, (%r15)
je 0x2c7d80
movq %rsp, %r12
movw $0x2, 0x24(%r12)
leaq 0x23e9(%rip), %rax      # 0x2ca123
movq %rax, 0x8(%r12)
leaq 0x24bf(%rip), %rax      # 0x2ca205
movq %rax, 0x10(%r12)
movl $0x0, 0x28(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2ca211
cmpw $0x0, 0x24(%r12)
je 0x2c7d80
movl $0x0, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2c7eee
jmp 0x2c7ddc
movb 0x1f(%r14), %al
testb %al, %al
je 0x2c7d9b
decb %al
movb %al, 0x1f(%r14)
movzbl %al, %eax
movl 0xd4(%r14,%rax,4), %ebp
jmp 0x2c7da5
movl 0x38(%r14), %ebp
incl %ebp
movl %ebp, 0x38(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2c6416
cmpl %ebp, %eax
jne 0x2c7dba
movl %ebp, %ecx
jmp 0x2c7dda
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x2c7dda
movzbl 0x1f(%r14), %edx
cmpq $0x7, %rdx
ja 0x2c7dda
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
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: codeCompare
static int codeCompare(
  Parse *pParse,    /* The parsing (and code generating) context */
  Expr *pLeft,      /* The left operand */
  Expr *pRight,     /* The right operand */
  int opcode,       /* The comparison opcode */
  int in1, int in2, /* Register holding operands */
  int dest,         /* Jump here if true.  */
  int jumpIfNull,   /* If true, jump if either operand is NULL */
  int isCommuted    /* The comparison has been commuted */
){
  int p5;
  int addr;
  CollSeq *p4;

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

// Assembly:
cmpl $0x0, 0x30(%rdi)
je 0x2c7df0
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
cmpl $0x0, 0x50(%rsp)
je 0x2c7e1c
movq %r12, %rsi
movq %r13, %rdx
jmp 0x2c7e22
movq %r13, %rsi
movq %r12, %rdx
callq 0x2b325c
movq %rax, (%rsp)
movq %r12, %rdi
callq 0x2ca042
movsbl %al, %esi
movq %r13, %rdi
callq 0x2ca0e4
movl %eax, %r12d
movq 0x10(%rbx), %r13
movq %r13, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl 0x40(%rsp), %ecx
movl %ebp, %r8d
callq 0x2b200c
movq %r13, %rdi
movl %eax, %esi
movq (%rsp), %rdx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
callq 0x285198
movq 0x10(%rbx), %rax
movslq 0x90(%rax), %rcx
testq %rcx, %rcx
jle 0x2c7e98
movl 0x48(%rsp), %edx
orb %dl, %r12b
movzbl %r12b, %edx
movq 0x88(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movw %dx, -0x16(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3GetTempRange
SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){
  int i, n;
  if( nReg==1 ) return sqlite3GetTempReg(pParse);
  i = pParse->iRangeReg;
  n = pParse->nRangeReg;
  if( nReg<=n ){
    pParse->iRangeReg += nReg;
    pParse->nRangeReg -= nReg;
  }else{
    i = pParse->nMem+1;
    pParse->nMem += nReg;
  }
  return i;
}

// Assembly:
cmpl $0x1, %esi
jne 0x2c8291
movb 0x1f(%rdi), %al
testb %al, %al
je 0x2c82b0
decb %al
movb %al, 0x1f(%rdi)
movzbl %al, %eax
movl 0xd4(%rdi,%rax,4), %eax
retq
movl 0x28(%rdi), %ecx
subl %esi, %ecx
jge 0x2c82a4
movl 0x38(%rdi), %ecx
leal 0x1(%rcx), %eax
addl %ecx, %esi
movl %esi, 0x38(%rdi)
retq
movl 0x2c(%rdi), %eax
addl %eax, %esi
movl %esi, 0x2c(%rdi)
movl %ecx, 0x28(%rdi)
retq
movl 0x38(%rdi), %eax
incl %eax
movl %eax, 0x38(%rdi)
retq