LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: getToken
static int getToken(const unsigned char **pz){
  const unsigned char *z = *pz;
  int t;                          /* Token type to return */
  do {
    z += sqlite3GetToken(z, &t);
  }while( t==TK_SPACE );
  if( t==TK_ID
   || t==TK_STRING
   || t==TK_JOIN_KW
   || t==TK_WINDOW
   || t==TK_OVER
   || sqlite3ParserFallback(t)==TK_ID
  ){
    t = TK_ID;
  }
  *pz = z;
  return t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rcx
leaq 0xc(%rsp), %r14
movq %rcx, %r15
movq %rcx, %rdi
movq %r14, %rsi
callq 0x24cef0
movslq %eax, %rcx
addq %r15, %rcx
movslq 0xc(%rsp), %rdx
cmpq $0xb3, %rdx
je 0x24e850
leal -0x3b(%rdx), %eax
cmpl $0x39, %eax
ja 0x24e88a
movabsq $0x300000000000001, %rsi # imm = 0x300000000000001
btq %rax, %rsi
jb 0x24e895
leal -0xa1(%rdx), %eax
cmpl $0x2, %eax
jae 0x24e8a5
pushq $0x3b
popq %rax
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x123e64(%rip), %rax    # 0x372710
cmpw $0x3b, (%rax,%rdx,2)
pushq $0x3b
popq %rax
cmovnel %edx, %eax
jmp 0x24e898
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: yyStackOverflow
static void yyStackOverflow(yyParser *yypParser){
   sqlite3ParserARG_FETCH
   sqlite3ParserCTX_FETCH
#ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
   }
#endif
   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
   /* Here code is inserted which will execute if the parser
   ** stack every overflows */
/******** Begin %stack_overflow code ******************************************/

  sqlite3ErrorMsg(pParse, "parser stack overflow");
/******** End %stack_overflow code ********************************************/
   sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument var */
   sqlite3ParserCTX_STORE
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x10(%rdi), %r15
cmpq %r15, (%rbx)
jbe 0x25364f
movq %rbx, %rdi
callq 0x2645a7
jmp 0x253640
leaq 0x124310(%rip), %rsi    # 0x377966
movq %r14, %rdi
xorl %eax, %eax
callq 0x226dce
movq %r14, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3AddDefaultValue
SQLITE_PRIVATE void sqlite3AddDefaultValue(
  Parse *pParse,           /* Parsing context */
  Expr *pExpr,             /* The parsed expression of the default value */
  const char *zStart,      /* Start of the default value text */
  const char *zEnd         /* First character past end of defaut value text */
){
  Table *p;
  Column *pCol;
  sqlite3 *db = pParse->db;
  p = pParse->pNewTable;
  if( p!=0 ){
    int isInit = db->init.busy && db->init.iDb!=1;
    pCol = &(p->aCol[p->nCol-1]);
    if( !sqlite3ExprIsConstantOrFunction(pExpr, isInit) ){
      sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
          pCol->zName);
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
    }else if( pCol->colFlags & COLFLAG_GENERATED ){
      testcase( pCol->colFlags & COLFLAG_VIRTUAL );
      testcase( pCol->colFlags & COLFLAG_STORED );
      sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
#endif
    }else{
      /* A copy of pExpr is used instead of the original, as pExpr contains
      ** tokens that point to volatile memory.
      */
      Expr x;
      sqlite3ExprDelete(db, pCol->pDflt);
      memset(&x, 0, sizeof(x));
      x.op = TK_SPAN;
      x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
      x.pLeft = pExpr;
      x.flags = EP_Skip;
      pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
      sqlite3DbFree(db, x.u.zToken);
    }
  }
  if( IN_RENAME_OBJECT ){
    sqlite3RenameExprUnmap(pParse, pExpr);
  }
  sqlite3ExprDelete(db, pExpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x148(%rdi), %rax
testq %rax, %rax
je 0x2548e6
movq %rcx, %rbp
movq %rdx, %r13
cmpb $0x0, 0xb5(%r14)
je 0x25482a
xorl %esi, %esi
cmpb $0x1, 0xb4(%r14)
sete %sil
xorl $0x5, %esi
jmp 0x25482d
pushq $0x4
popq %rsi
movswq 0x46(%rax), %r12
shlq $0x5, %r12
addq 0x8(%rax), %r12
movq %rbx, %rdi
xorl %edx, %edx
callq 0x267e62
testl %eax, %eax
je 0x254866
testb $0x60, -0x4(%r12)
je 0x25487e
leaq 0x123d16(%rip), %rsi    # 0x37856d
movq %r15, %rdi
xorl %eax, %eax
callq 0x226dce
jmp 0x2548e6
movq -0x20(%r12), %rdx
leaq 0x123cce(%rip), %rsi    # 0x378540
movq %r15, %rdi
xorl %eax, %eax
callq 0x226dce
jmp 0x2548e6
movq -0x18(%r12), %rsi
movq %r14, %rdi
callq 0x24b639
xorps %xmm0, %xmm0
movq %rbp, %rdx
movq %rsp, %rbp
movaps %xmm0, (%rbp)
movaps %xmm0, 0x30(%rbp)
movaps %xmm0, 0x20(%rbp)
movaps %xmm0, 0x10(%rbp)
andq $0x0, 0x40(%rbp)
movb $-0x4e, (%rbp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x26f5b0
movq %rax, 0x8(%rbp)
movq %rbx, 0x10(%rbp)
movl $0x1000, 0x4(%rbp)      # imm = 0x1000
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x267197
movq %rax, -0x18(%r12)
movq 0x8(%rbp), %rsi
movq %r14, %rdi
callq 0x21f26b
cmpb $0x2, 0x11c(%r15)
jb 0x2548fb
movq %r15, %rdi
movq %rbx, %rsi
callq 0x26f5fb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24b639
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PExpr
SQLITE_PRIVATE Expr *sqlite3PExpr(
  Parse *pParse,          /* Parsing context */
  int op,                 /* Expression opcode */
  Expr *pLeft,            /* Left operand */
  Expr *pRight            /* Right operand */
){
  Expr *p;
  p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr));
  if( p ){
    memset(p, 0, sizeof(Expr));
    p->op = op & 0xff;
    p->iAgg = -1;
    sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
    sqlite3ExprCheckHeight(pParse, p->nHeight);
  }else{
    sqlite3ExprDelete(pParse->db, pLeft);
    sqlite3ExprDelete(pParse->db, pRight);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rdi
pushq $0x48
popq %rsi
callq 0x22d205
movq %rax, %rbx
testq %rax, %rax
je 0x254978
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x40(%rbx)
movb %bpl, (%rbx)
orw $-0x1, 0x32(%rbx)
movq (%r15), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x26106c
movl 0x28(%rbx), %esi
movq %r15, %rdi
callq 0x26cf29
jmp 0x25498e
movq (%r15), %rdi
movq %r12, %rsi
callq 0x24b639
movq (%r15), %rdi
movq %r14, %rsi
callq 0x24b639
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: tokenExpr
static Expr *tokenExpr(Parse *pParse, int op, Token t){
    Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
    if( p ){
      /* memset(p, 0, sizeof(Expr)); */
      p->op = (u8)op;
      p->affExpr = 0;
      p->flags = EP_Leaf;
      ExprClearVVAProperties(p);
      p->iAgg = -1;
      p->pLeft = p->pRight = 0;
      p->x.pList = 0;
      p->pAggInfo = 0;
      p->y.pTab = 0;
      p->op2 = 0;
      p->iTable = 0;
      p->iColumn = 0;
      p->u.zToken = (char*)&p[1];
      memcpy(p->u.zToken, t.z, t.n);
      p->u.zToken[t.n] = 0;
      if( sqlite3Isquote(p->u.zToken[0]) ){
        sqlite3DequoteExpr(p);
      }
#if SQLITE_MAX_EXPR_DEPTH>0
      p->nHeight = 1;
#endif
      if( IN_RENAME_OBJECT ){
        return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t);
      }
    }
    return p;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, (%rsp)
movl %ecx, 0x8(%rsp)
movq (%rdi), %rdi
movl %ecx, %r12d
leaq 0x49(%r12), %rsi
callq 0x22d205
movq %rax, %r14
testq %rax, %rax
je 0x254a58
movb %bpl, (%r14)
andw $0x0, 0x1(%r14)
movl $0x800000, 0x4(%r14)    # imm = 0x800000
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
movq %rax, 0x2c(%r14)
movq %r14, %rdi
addq $0x48, %rdi
andq $0x0, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x38(%r14)
movq %rdi, 0x8(%r14)
movq %r15, %rsi
movq %r12, %rdx
callq 0x17630
movb $0x0, 0x48(%r14,%r12)
movzbl 0x48(%r14), %eax
leaq 0x11ce25(%rip), %rcx    # 0x371850
cmpb $0x0, (%rax,%rcx)
jns 0x254a39
movq %r14, %rdi
callq 0x26f880
movl $0x1, 0x28(%r14)
cmpb $0x2, 0x11c(%rbx)
jb 0x254a58
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25c05b
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprIdToTrueFalse
SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
  u32 v;
  assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
  if( !ExprHasProperty(pExpr, EP_Quoted)
   && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
  ){
    pExpr->op = TK_TRUEFALSE;
    ExprSetProperty(pExpr, v);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x4(%rdi), %ebp
xorl %ebx, %ebx
btl $0x1a, %ebp
jb 0x254a94
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x26edc7
testl %eax, %eax
je 0x254a94
movb $-0x59, (%r14)
orl %ebp, %eax
movl %eax, 0x4(%r14)
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3AddCheckConstraint
SQLITE_PRIVATE void sqlite3AddCheckConstraint(
  Parse *pParse,    /* Parsing context */
  Expr *pCheckExpr  /* The check expression */
){
#ifndef SQLITE_OMIT_CHECK
  Table *pTab = pParse->pNewTable;
  sqlite3 *db = pParse->db;
  if( pTab && !IN_DECLARE_VTAB
   && !sqlite3BtreeIsReadonly(db->aDb[db->init.iDb].pBt)
  ){
    pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
    if( pParse->constraintName.n ){
      sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
    }
  }else
#endif
  {
    sqlite3ExprDelete(pParse->db, pCheckExpr);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x148(%rbx), %r14
testq %r14, %r14
je 0x255b64
cmpb $0x1, 0x11c(%rbx)
je 0x255b64
movq 0x20(%rdi), %rax
movzbl 0xb4(%rdi), %ecx
shll $0x5, %ecx
movq 0x8(%rax,%rcx), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x28(%rax)
jne 0x255b64
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x25bc95
movq %rax, 0x30(%r14)
cmpl $0x0, 0x68(%rbx)
je 0x255b73
leaq 0x60(%rbx), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x25bd24
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24b639
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3AddGenerated
SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  u8 eType = COLFLAG_VIRTUAL;
  Table *pTab = pParse->pNewTable;
  Column *pCol;
  if( pTab==0 ){
    /* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
    goto generated_done;
  }
  pCol = &(pTab->aCol[pTab->nCol-1]);
  if( IN_DECLARE_VTAB ){
    sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
    goto generated_done;
  }
  if( pCol->pDflt ) goto generated_error;
  if( pType ){
    if( pType->n==7 && sqlite3StrNICmp("virtual",pType->z,7)==0 ){
      /* no-op */
    }else if( pType->n==6 && sqlite3StrNICmp("stored",pType->z,6)==0 ){
      eType = COLFLAG_STORED;
    }else{
      goto generated_error;
    }
  }
  if( eType==COLFLAG_VIRTUAL ) pTab->nNVCol--;
  pCol->colFlags |= eType;
  assert( TF_HasVirtual==COLFLAG_VIRTUAL );
  assert( TF_HasStored==COLFLAG_STORED );
  pTab->tabFlags |= eType;
  if( pCol->colFlags & COLFLAG_PRIMKEY ){
    makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
  }
  pCol->pDflt = pExpr;
  pExpr = 0;
  goto generated_done;

generated_error:
  sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
                  pCol->zName);
generated_done:
  sqlite3ExprDelete(pParse->db, pExpr);
#else
  /* Throw and error for the GENERATED ALWAYS AS clause if the
  ** SQLITE_OMIT_GENERATED_COLUMNS compile-time option is used. */
  sqlite3ErrorMsg(pParse, "generated columns not supported");
  sqlite3ExprDelete(pParse->db, pExpr);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x148(%rdi), %r12
testq %r12, %r12
je 0x255fed
cmpb $0x1, 0x11c(%r14)
jne 0x255fb7
leaq 0x122971(%rip), %rsi    # 0x37891c
movq %r14, %rdi
xorl %eax, %eax
callq 0x226dce
jmp 0x255fed
movq 0x8(%r12), %rax
movswq 0x46(%r12), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %r13
leaq (%rax,%rcx), %r15
addq $-0x20, %r15
cmpq $0x0, -0x18(%r13)
je 0x256001
movq (%r15), %rdx
leaq 0x12296c(%rip), %rsi    # 0x37894f
movq %r14, %rdi
xorl %eax, %eax
callq 0x226dce
movq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x24b639
testq %rdx, %rdx
je 0x256029
movl 0x8(%rdx), %eax
cmpl $0x6, %eax
je 0x25605d
cmpl $0x7, %eax
jne 0x255fd9
movq (%rdx), %rsi
leaq 0x12292a(%rip), %rdi    # 0x378947
pushq $0x7
popq %rdx
callq 0x2217ad
testl %eax, %eax
jne 0x255fd9
decw 0x48(%r12)
pushq $0x20
popq %rax
movzwl -0x4(%r13), %ecx
movl %ecx, %edx
orl %eax, %edx
movw %dx, -0x4(%r13)
orl %eax, 0x40(%r12)
testb $0x1, %cl
je 0x256055
movq %r14, %rdi
movq %r15, %rsi
callq 0x26f8a3
movq %rbx, -0x18(%r13)
xorl %ebx, %ebx
jmp 0x255fed
movq (%rdx), %rsi
leaq 0xc32d5(%rip), %rdi     # 0x31933c
pushq $0x6
popq %rdx
callq 0x2217ad
testl %eax, %eax
jne 0x255fd9
pushq $0x40
jmp 0x256031
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: parserDoubleLinkSelect
static void parserDoubleLinkSelect(Parse *pParse, Select *p){
    assert( p!=0 );
    if( p->pPrior ){
      Select *pNext = 0, *pLoop;
      int mxSelect, cnt = 0;
      for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
        pLoop->pNext = pNext;
        pLoop->selFlags |= SF_Compound;
      }
      if( (p->selFlags & SF_MultiValue)==0 &&
        (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0 &&
        cnt>mxSelect
      ){
        sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
      }
    }
  }

// Assembly:
cmpq $0x0, 0x50(%rsi)
je 0x25ba2d
xorl %ecx, %ecx
movq %rsi, %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x25ba00
movq %rdx, %r8
movq %rcx, 0x58(%rdx)
orb $0x1, 0x5(%rdx)
movq 0x50(%rdx), %rdx
incl %eax
movq %r8, %rcx
jmp 0x25b9e5
testb $0x4, 0x5(%rsi)
jne 0x25ba2d
movq (%rdi), %rcx
movl 0x8c(%rcx), %ecx
testl %ecx, %ecx
setg %dl
cmpl %ecx, %eax
setg %al
andb %dl, %al
cmpb $0x1, %al
jne 0x25ba2d
leaq 0x11d62f(%rip), %rsi    # 0x379055
xorl %eax, %eax
jmp 0x226dce
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListAppendFromTerm
SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(
  Parse *pParse,          /* Parsing context */
  SrcList *p,             /* The left part of the FROM clause already seen */
  Token *pTable,          /* Name of the table to add to the FROM clause */
  Token *pDatabase,       /* Name of the database containing pTable */
  Token *pAlias,          /* The right-hand side of the AS subexpression */
  Select *pSubquery,      /* A subquery used in place of a table name */
  Expr *pOn,              /* The ON clause of a join */
  IdList *pUsing          /* The USING clause of a join */
){
  struct SrcList_item *pItem;
  sqlite3 *db = pParse->db;
  if( !p && (pOn || pUsing) ){
    sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
      (pOn ? "ON" : "USING")
    );
    goto append_from_error;
  }
  p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
  if( p==0 ){
    goto append_from_error;
  }
  assert( p->nSrc>0 );
  pItem = &p->a[p->nSrc-1];
  assert( (pTable==0)==(pDatabase==0) );
  assert( pItem->zName==0 || pDatabase!=0 );
  if( IN_RENAME_OBJECT && pItem->zName ){
    Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
    sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
  }
  assert( pAlias!=0 );
  if( pAlias->n ){
    pItem->zAlias = sqlite3NameFromToken(db, pAlias);
  }
  pItem->pSelect = pSubquery;
  pItem->pOn = pOn;
  pItem->pUsing = pUsing;
  return p;

 append_from_error:
  assert( p==0 );
  sqlite3ExprDelete(db, pOn);
  sqlite3IdListDelete(db, pUsing);
  sqlite3SelectDelete(db, pSubquery);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r13
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %rbp
movq 0x50(%rsp), %rcx
movq (%rdi), %r15
testq %rsi, %rsi
jne 0x25ba8a
movq %rcx, %rax
orq 0x58(%rsp), %rax
je 0x25ba8a
testq %rcx, %rcx
leaq 0x11c9ff(%rip), %rax    # 0x378468
leaq 0x11d62b(%rip), %rdx    # 0x37909b
cmovneq %rax, %rdx
leaq 0x11d5fc(%rip), %rsi    # 0x379077
movq %rbp, %rdi
xorl %eax, %eax
callq 0x226dce
jmp 0x25bb19
movq %r8, 0x10(%rsp)
movq %rbp, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x25bf69
testq %rax, %rax
je 0x25bb19
movq %rax, %r14
movq %r13, 0x8(%rsp)
movslq (%rax), %rax
imulq $0x70, %rax, %rax
leaq (%rax,%r14), %r13
addq $-0x68, %r13
cmpb $0x2, 0x11c(%rbp)
jb 0x25bae5
movq 0x10(%r13), %rsi
testq %rsi, %rsi
je 0x25bae5
testq %r12, %r12
je 0x25bad7
cmpq $0x0, (%r12)
jne 0x25bada
movq %rbx, %r12
movq %rbp, %rdi
movq %r12, %rdx
callq 0x25c05b
movq 0x10(%rsp), %rsi
cmpl $0x0, 0x8(%rsi)
je 0x25bafc
movq %r15, %rdi
callq 0x25c0a8
movq %rax, 0x18(%r13)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%r13)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%r13)
movq 0x58(%rsp), %rax
movq %rax, 0x50(%r13)
jmp 0x25bb41
movq %r15, %rdi
movq 0x50(%rsp), %rsi
callq 0x24b639
movq %r15, %rdi
movq 0x58(%rsp), %rsi
callq 0x24b97f
movq %r15, %rdi
movq %r13, %rsi
callq 0x24b6e9
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprListAppend
SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to append. Might be NULL */
  Expr *pExpr             /* Expression to be appended. Might be NULL */
){
  struct ExprList_item *pItem;
  sqlite3 *db = pParse->db;
  assert( db!=0 );
  if( pList==0 ){
    pList = sqlite3DbMallocRawNN(db, sizeof(ExprList) );
    if( pList==0 ){
      goto no_mem;
    }
    pList->nExpr = 0;
  }else if( (pList->nExpr & (pList->nExpr-1))==0 ){
    ExprList *pNew;
    pNew = sqlite3DbRealloc(db, pList,
         sizeof(*pList)+(2*(sqlite3_int64)pList->nExpr-1)*sizeof(pList->a[0]));
    if( pNew==0 ){
      goto no_mem;
    }
    pList = pNew;
  }
  pItem = &pList->a[pList->nExpr++];
  assert( offsetof(struct ExprList_item,zEName)==sizeof(pItem->pExpr) );
  assert( offsetof(struct ExprList_item,pExpr)==0 );
  memset(&pItem->zEName,0,sizeof(*pItem)-offsetof(struct ExprList_item,zEName));
  pItem->pExpr = pExpr;
  return pList;

no_mem:
  /* Avoid leaking memory if malloc has failed. */
  sqlite3ExprDelete(db, pExpr);
  sqlite3ExprListDelete(db, pList);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %r15
testq %rsi, %rsi
je 0x25bcd0
movl (%rbx), %ecx
leal -0x1(%rcx), %eax
testl %eax, %ecx
jne 0x25bce8
movslq %ecx, %rax
imulq $0x30, %rax, %rdx
orq $0x8, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22d1b5
testq %rax, %rax
je 0x25bd03
movl (%rax), %ecx
jmp 0x25bce5
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x22d205
testq %rax, %rax
je 0x25bd03
andl $0x0, (%rax)
xorl %ecx, %ecx
movq %rax, %rbx
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
movslq %ecx, %rax
imulq $0x18, %rax, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx,%rax)
movq %r14, 0x8(%rbx,%rax)
jmp 0x25bd1b
movq %r15, %rdi
movq %r14, %rsi
callq 0x24b639
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24b63f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprListSetName
SQLITE_PRIVATE void sqlite3ExprListSetName(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to add the span. */
  Token *pName,           /* Name to be added */
  int dequote             /* True to cause the name to be dequoted */
){
  assert( pList!=0 || pParse->db->mallocFailed!=0 );
  assert( pParse->eParseMode!=PARSE_MODE_UNMAP || dequote==0 );
  if( pList ){
    struct ExprList_item *pItem;
    assert( pList->nExpr>0 );
    pItem = &pList->a[pList->nExpr-1];
    assert( pItem->zEName==0 );
    assert( pItem->eEName==ENAME_NAME );
    pItem->zEName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
    if( dequote ){
      /* If dequote==0, then pName->z does not point to part of a DDL
      ** statement handled by the parser. And so no token need be added
      ** to the token-map.  */
      sqlite3Dequote(pItem->zEName);
      if( IN_RENAME_OBJECT ){
        sqlite3RenameTokenMap(pParse, (void*)pItem->zEName, pName);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x25bd8a
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq (%rsi), %r12
movq (%rdi), %rdi
movq (%rdx), %rsi
movl 0x8(%rdx), %edx
callq 0x24b168
imulq $0x18, %r12, %r12
movq %rax, -0x8(%r15,%r12)
testl %ebp, %ebp
je 0x25bd8a
movq %rax, %rdi
callq 0x26f55e
cmpb $0x2, 0x11c(%r14)
jb 0x25bd8a
leaq (%r15,%r12), %rax
addq $-0x8, %rax
movq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25c05b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAlloc
SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
  sqlite3 *db,            /* Handle for sqlite3DbMallocRawNN() */
  int op,                 /* Expression opcode */
  const Token *pToken,    /* Token argument.  Might be NULL */
  int dequote             /* True to dequote */
){
  Expr *pNew;
  int nExtra = 0;
  int iValue = 0;

  assert( db!=0 );
  if( pToken ){
    if( op!=TK_INTEGER || pToken->z==0
          || sqlite3GetInt32(pToken->z, &iValue)==0 ){
      nExtra = pToken->n+1;
      assert( iValue>=0 );
    }
  }
  pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra);
  if( pNew ){
    memset(pNew, 0, sizeof(Expr));
    pNew->op = (u8)op;
    pNew->iAgg = -1;
    if( pToken ){
      if( nExtra==0 ){
        pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse);
        pNew->u.iValue = iValue;
      }else{
        pNew->u.zToken = (char*)&pNew[1];
        assert( pToken->z!=0 || pToken->n==0 );
        if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
        pNew->u.zToken[pToken->n] = 0;
        if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){
          sqlite3DequoteExpr(pNew);
        }
      }
    }
#if SQLITE_MAX_EXPR_DEPTH>0
    pNew->nHeight = 1;
#endif
  }
  return pNew;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
andl $0x0, 0xc(%rsp)
movl %esi, %ebp
movq %rdi, %r15
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x25be14
cmpl $0x98, %ebp
jne 0x25be0d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x25be0d
leaq 0xc(%rsp), %rsi
callq 0x24b4cc
testl %eax, %eax
jne 0x25be14
movl 0x8(%r14), %r12d
incl %r12d
movslq %r12d, %rsi
addq $0x48, %rsi
movq %r15, %rdi
callq 0x22d205
movq %rax, %r15
testq %rax, %rax
je 0x25becd
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r15)
andq $0x0, 0x40(%r15)
orw $-0x1, 0x32(%r15)
movups %xmm0, (%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movb %bpl, (%r15)
testq %r14, %r14
je 0x25bec5
testl %r12d, %r12d
je 0x25be82
movq %r15, %r12
addq $0x48, %r12
movq %r12, 0x8(%r15)
movl 0x8(%r14), %edx
testq %rdx, %rdx
je 0x25bea0
movq (%r14), %rsi
movq %r12, %rdi
callq 0x17630
movl 0x8(%r14), %eax
jmp 0x25bea2
movl 0xc(%rsp), %eax
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
shll $0x1c, %ecx
addl $0x10800400, %ecx       # imm = 0x10800400
movl %ecx, 0x4(%r15)
movl %eax, 0x8(%r15)
jmp 0x25bec5
xorl %eax, %eax
movb $0x0, (%r12,%rax)
testl %ebx, %ebx
je 0x25bec5
movzbl (%r12), %eax
leaq 0x115999(%rip), %rcx    # 0x371850
cmpb $0x0, (%rax,%rcx)
jns 0x25bec5
movq %r15, %rdi
callq 0x26f880
movl $0x1, 0x28(%r15)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListShiftJoinType
SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){
  if( p ){
    int i;
    for(i=p->nSrc-1; i>0; i--){
      p->a[i].fg.jointype = p->a[i-1].fg.jointype;
    }
    p->a[0].fg.jointype = 0;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x25bf05
movl (%rdi), %eax
imulq $0x70, %rax, %rcx
addq %rdi, %rcx
addq $-0x2c, %rcx
cmpl $0x2, %eax
jl 0x25bf01
movb -0x70(%rcx), %dl
movb %dl, (%rcx)
addq $-0x70, %rcx
decl %eax
jmp 0x25beef
movb $0x0, 0x44(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListIndexedBy
SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
  assert( pIndexedBy!=0 );
  if( p && pIndexedBy->n>0 ){
    struct SrcList_item *pItem;
    assert( p->nSrc>0 );
    pItem = &p->a[p->nSrc-1];
    assert( pItem->fg.notIndexed==0 );
    assert( pItem->fg.isIndexedBy==0 );
    assert( pItem->fg.isTabFunc==0 );
    if( pIndexedBy->n==1 && !pIndexedBy->z ){
      /* A "NOT INDEXED" clause was supplied. See parse.y
      ** construct "indexed_opt" for details. */
      pItem->fg.notIndexed = 1;
    }else{
      pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
      pItem->fg.isIndexedBy = 1;
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x25bf42
movl 0x8(%rdx), %eax
testl %eax, %eax
je 0x25bf42
pushq %rbx
movslq (%rsi), %rcx
imulq $0x70, %rcx, %rcx
leaq (%rcx,%rsi), %rbx
addq $-0x68, %rbx
cmpl $0x1, %eax
jne 0x25bf2d
cmpq $0x0, (%rdx)
je 0x25bf43
movq (%rdi), %rdi
movq %rdx, %rsi
callq 0x25c0a8
movq %rax, 0x60(%rbx)
movb $0x2, %al
orb %al, 0x3d(%rbx)
popq %rbx
retq
movb $0x1, %al
jmp 0x25bf3e
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListAppend
SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
  Parse *pParse,      /* Parsing context, in which errors are reported */
  SrcList *pList,     /* Append to this SrcList. NULL creates a new SrcList */
  Token *pTable,      /* Table to append */
  Token *pDatabase    /* Database of the table */
){
  struct SrcList_item *pItem;
  sqlite3 *db;
  assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
  assert( pParse!=0 );
  assert( pParse->db!=0 );
  db = pParse->db;
  if( pList==0 ){
    pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
    if( pList==0 ) return 0;
    pList->nAlloc = 1;
    pList->nSrc = 1;
    memset(&pList->a[0], 0, sizeof(pList->a[0]));
    pList->a[0].iCursor = -1;
  }else{
    SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
    if( pNew==0 ){
      sqlite3SrcListDelete(db, pList);
      return 0;
    }else{
      pList = pNew;
    }
  }
  pItem = &pList->a[pList->nSrc-1];
  if( pDatabase && pDatabase->z==0 ){
    pDatabase = 0;
  }
  if( pDatabase ){
    pItem->zName = sqlite3NameFromToken(db, pDatabase);
    pItem->zDatabase = sqlite3NameFromToken(db, pTable);
  }else{
    pItem->zName = sqlite3NameFromToken(db, pTable);
    pItem->zDatabase = 0;
  }
  return pList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq (%rdi), %r15
testq %rsi, %rsi
je 0x25bfa1
movq %rsi, %r13
movl (%rsi), %ecx
pushq $0x1
popq %rdx
callq 0x275a22
testq %rax, %rax
je 0x25c040
movq %rax, %r14
movslq (%rax), %rax
decq %rax
jmp 0x25bff2
pushq $0x78
popq %rsi
movq %r15, %rdi
callq 0x22d205
testq %rax, %rax
je 0x25c04b
movq %rax, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
orl $-0x1, 0x48(%r14)
xorl %eax, %eax
imulq $0x70, %rax, %rax
leaq (%r14,%rax), %r13
addq $0x8, %r13
testq %r12, %r12
je 0x25c02a
cmpq $0x0, (%r12)
je 0x25c02a
movq %r15, %rdi
movq %r12, %rsi
callq 0x25c0a8
movq %rax, 0x10(%r13)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x25c0a8
movq %rax, 0x8(%r13)
jmp 0x25c04e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x25c0a8
movq %rax, 0x10(%r13)
andq $0x0, 0x8(%r13)
jmp 0x25c04e
movq %r15, %rdi
movq %r13, %rsi
callq 0x24b836
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RenameTokenMap
SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pToken){
  RenameToken *pNew;
  assert( pPtr || pParse->db->mallocFailed );
  renameTokenCheckAll(pParse, pPtr);
  if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){
    pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
    if( pNew ){
      pNew->p = pPtr;
      pNew->t = *pToken;
      pNew->pNext = pParse->pRename;
      pParse->pRename = pNew;
    }
  }

  return pPtr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x3, 0x11c(%rdi)
je 0x25c09f
movq %rdx, %r15
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x20
popq %rsi
callq 0x2258ed
testq %rax, %rax
je 0x25c09f
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x1a0(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x1a0(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListAppendList
SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){
  assert( p1 && p1->nSrc==1 );
  if( p2 ){
    SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
    if( pNew==0 ){
      sqlite3SrcListDelete(pParse->db, p2);
    }else{
      p1 = pNew;
      memcpy(&p1->a[1], p2->a, p2->nSrc*sizeof(struct SrcList_item));
      sqlite3DbFree(pParse->db, p2);
    }
  }
  return p1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdx, %rdx
je 0x25cd01
movq %rdx, %rbx
movq %rdi, %r15
movl (%rdx), %edx
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x275a22
testq %rax, %rax
je 0x25ccf6
movq %rax, %r12
movq %rax, %rdi
addq $0x78, %rdi
leaq 0x8(%rbx), %rsi
movslq (%rbx), %rax
imulq $0x70, %rax, %rdx
callq 0x17630
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x22d0fc
movq %r12, %r14
jmp 0x25cd01
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x24b836
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3UpsertNew
SQLITE_PRIVATE Upsert *sqlite3UpsertNew(
  sqlite3 *db,           /* Determines which memory allocator to use */
  ExprList *pTarget,     /* Target argument to ON CONFLICT, or NULL */
  Expr *pTargetWhere,    /* Optional WHERE clause on the target */
  ExprList *pSet,        /* UPDATE columns, or NULL for a DO NOTHING */
  Expr *pWhere           /* WHERE clause for the ON CONFLICT UPDATE */
){
  Upsert *pNew;
  pNew = sqlite3DbMallocRaw(db, sizeof(Upsert));
  if( pNew==0 ){
    sqlite3ExprListDelete(db, pTarget);
    sqlite3ExprDelete(db, pTargetWhere);
    sqlite3ExprListDelete(db, pSet);
    sqlite3ExprDelete(db, pWhere);
    return 0;
  }else{
    pNew->pUpsertTarget = pTarget;
    pNew->pUpsertTargetWhere = pTargetWhere;
    pNew->pUpsertSet = pSet;
    pNew->pUpsertWhere = pWhere;
    pNew->pUpsertIdx = 0;
  }
  return pNew;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
pushq $0x40
popq %rsi
callq 0x22809f
movq %rax, %r14
testq %rax, %rax
je 0x260f5d
movq %rbp, (%r14)
movq %r13, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %rbx, 0x18(%r14)
andq $0x0, 0x20(%r14)
jmp 0x260f89
movq %r12, %rdi
movq %rbp, %rsi
callq 0x24b63f
movq %r12, %rdi
movq %r13, %rsi
callq 0x24b639
movq %r12, %rdi
movq %r15, %rsi
callq 0x24b63f
movq %r12, %rdi
movq %rbx, %rsi
callq 0x24b639
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x260fcc
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0x2258ed
movq %rax, %rbx
testq %rax, %rax
je 0x26102f
movq (%rbx), %rsi
leaq 0x8(%rbx), %rcx
pushq $0x10
popq %rdx
leaq 0xc(%rsp), %r13
movq %r12, %rdi
movq %r13, %r8
callq 0x27e88a
movq %rax, (%rbx)
movslq (%r13), %r13
movq %r12, %rdi
testq %r13, %r13
js 0x261027
movq %r14, %rsi
callq 0x25c0a8
movq (%rbx), %rcx
shlq $0x4, %r13
movq %rax, (%rcx,%r13)
testq %rax, %rax
je 0x261031
cmpb $0x2, 0x11c(%r15)
jb 0x261031
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x25c05b
jmp 0x261031
movq %rbx, %rsi
callq 0x24b97f
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_O2/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 0x261067
movq (%rdi), %rdi
pushq $0x6f
popq %rsi
callq 0x25bdcc
testq %rax, %rax
je 0x261067
movq %rbx, 0x10(%rax)
orb $0x11, 0x5(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2610af
testq %rbx, %rbx
je 0x26108c
movq %rbx, 0x18(%rsi)
movl $0x200104, %eax         # imm = 0x200104
andl 0x4(%rbx), %eax
orl %eax, 0x4(%rsi)
testq %rdx, %rdx
je 0x2610a0
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 0x28326e
movq %rdi, %r14
movq %rdx, %rsi
callq 0x24b639
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24b639
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rcx
movq %r13, %rdi
movl $0xa9, %esi
callq 0x25bdcc
movq %rax, %rbx
testq %rax, %rax
je 0x261142
testq %r14, %r14
je 0x261124
movl (%r14), %eax
movq (%r15), %rcx
cmpl 0x94(%rcx), %eax
jle 0x261124
leaq 0x118233(%rip), %rsi    # 0x37934a
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x226dce
movq %r14, 0x20(%rbx)
orb $0x4, 0x4(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2612a2
cmpl $0x1, %ebp
jne 0x26114d
orb $0x2, 0x4(%rbx)
jmp 0x26114d
movq %r13, %rdi
movq %r14, %rsi
callq 0x24b63f
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_O2/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 0x261185
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 0x261184
cmpb $-0x5d, 0x20(%rdx)
jne 0x261190
retq
movq (%rdi), %rdi
movq %rdx, %rsi
jmp 0x24b6f4
leaq 0x1181d5(%rip), %rsi    # 0x37936c
xorl %eax, %eax
jmp 0x226dce
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdx, %rbx
testq %rsi, %rsi
je 0x2611ef
movq %rsi, %rdx
testq %rbx, %rbx
je 0x2611ec
movq (%rdi), %r14
movl $0x20000001, %eax       # imm = 0x20000001
movl 0x4(%rdx), %ecx
andl %eax, %ecx
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x2611d1
andl 0x4(%rbx), %eax
cmpl $0x20000000, %eax       # imm = 0x20000000
jne 0x2611da
cmpb $0x1, 0x11c(%rdi)
jbe 0x2611fa
pushq $0x2c
popq %rsi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x254915
movq %rdx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rdx, %rsi
callq 0x24b649
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24b649
leaq 0xadade(%rip), %rdx     # 0x30ecf5
movq %r14, %rdi
movl $0x98, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x25bd93
// File: /workspace/github_c_makefile_star2_O2/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 0x261260
cmpb $0x77, (%rsi)
jne 0x261260
cmpb $0x1, 0x11c(%rdi)
ja 0x261260
movq (%rdi), %rdi
movb %cl, (%rbx)
movq 0x18(%rbx), %rsi
callq 0x24b639
andq $0x0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x261297
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x2, 0x11c(%rdi)
jb 0x261285
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26f5fb
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24b649
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25bc95
movq %rax, %r15
notl %ebp
orl %r12d, %ebp
je 0x261333
movq (%r14), %rax
cmpb $0x0, 0xb5(%rax)
jne 0x261333
movl 0x8(%rbx), %edx
movq (%rbx), %rcx
leaq 0x118072(%rip), %rsi    # 0x37939b
movq %r14, %rdi
xorl %eax, %eax
callq 0x226dce
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x25bd24
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
callq 0x2645be
testq %rax, %rax
je 0x261400
cmpl $0x0, 0x30(%r14)
jne 0x261400
movq %rax, %r15
xorl %r12d, %r12d
movl $0x0, %ebp
testq %r13, %r13
je 0x2613af
movq %rsp, %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r13, %rdx
callq 0x26a6d7
movl %eax, %ebp
testl %eax, %eax
sets %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
jne 0x261400
testq %rbx, %rbx
je 0x2613e6
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x26a995
testl %eax, %eax
jne 0x2613e6
movl 0x38(%r14), %r12d
incl %r12d
movl %r12d, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x26463f
pushq $0x8
popq %rsi
movq %r15, %rdi
movl %ebp, %edx
movl %r12d, %ecx
callq 0x24d51a
movq %r15, %rdi
movl %ebp, %esi
callq 0x2270bc
movq (%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24b639