LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaLocate
static const PragmaName *pragmaLocate(const char *zName){
  int upr, lwr, mid = 0, rc;
  lwr = 0;
  upr = ArraySize(aPragmaName)-1;
  while( lwr<=upr ){
    mid = (lwr+upr)/2;
    rc = sqlite3_stricmp(zName, aPragmaName[mid].zName);
    if( rc==0 ) break;
    if( rc<0 ){
      upr = mid - 1;
    }else{
      lwr = mid + 1;
    }
  }
  return lwr>upr ? 0 : &aPragmaName[mid];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x40, %ecx
leaq 0x20e3fe(%rip), %rdx    # 0x4b6ca0
leaq 0x128a37(%rip), %rsi    # 0x3d12e0
xorl %r8d, %r8d
leal (%rcx,%r8), %eax
movl %eax, %r9d
shrl $0x1f, %r9d
addl %eax, %r9d
sarl %r9d
movslq %r9d, %rax
leaq (%rax,%rax,2), %rax
leaq (%rdx,%rax,8), %rax
movq (%rax), %r10
testq %rdi, %rdi
je 0x2a8900
testq %r10, %r10
je 0x2a8910
xorl %r11d, %r11d
movzbl (%rdi,%r11), %ebx
movzbl (%r10,%r11), %r14d
cmpb %r14b, %bl
jne 0x2a88ee
testq %rbx, %rbx
jne 0x2a88fb
jmp 0x2a8933
movzbl (%rbx,%rsi), %ebx
movzbl (%r14,%rsi), %ebp
subl %ebp, %ebx
jne 0x2a890a
incq %r11
jmp 0x2a88d8
negq %r10
movl $0x0, %ebx
sbbl %ebx, %ebx
testl %ebx, %ebx
jne 0x2a8915
jmp 0x2a8933
movl $0x1, %ebx
leal -0x1(%r9), %eax
incl %r9d
testl %ebx, %ebx
cmovsl %r8d, %r9d
cmovsl %eax, %ecx
movl %r9d, %r8d
cmpl %ecx, %r9d
jle 0x2a88ac
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VtabCreateModule
SQLITE_PRIVATE Module *sqlite3VtabCreateModule(
  sqlite3 *db,                    /* Database in which module is registered */
  const char *zName,              /* Name assigned to this module */
  const sqlite3_module *pModule,  /* The definition of the module */
  void *pAux,                     /* Context pointer for xCreate/xConnect */
  void (*xDestroy)(void *)        /* Module destructor function */
){
  Module *pMod;
  Module *pDel;
  char *zCopy;
  if( pModule==0 ){
    zCopy = (char*)zName;
    pMod = 0;
  }else{
    int nName = sqlite3Strlen30(zName);
    pMod = (Module *)sqlite3Malloc(sizeof(Module) + nName + 1);
    if( pMod==0 ){
      sqlite3OomFault(db);
      return 0;
    }
    zCopy = (char *)(&pMod[1]);
    memcpy(zCopy, zName, nName+1);
    pMod->zName = zCopy;
    pMod->pModule = pModule;
    pMod->pAux = pAux;
    pMod->xDestroy = xDestroy;
    pMod->pEpoTab = 0;
    pMod->nRefModule = 1;
  }
  pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
  if( pDel ){
    if( pDel==pMod ){
      sqlite3OomFault(db);
      sqlite3DbFree(db, pDel);
      pMod = 0;
    }else{
      sqlite3VtabEponymousTableClear(db, pDel);
      sqlite3VtabModuleUnref(db, pDel);
    }
  }
  return pMod;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %rbx
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x2a89dc
movq %r8, %r15
movq %rdx, %rbp
movq %rcx, 0x10(%rsp)
testq %r13, %r13
je 0x2a897a
movq %r13, %rdi
callq 0x172f0
movq %rax, %r12
andl $0x3fffffff, %r12d      # imm = 0x3FFFFFFF
leal 0x31(%r12), %edi
callq 0x272ae6
testq %rax, %rax
je 0x2a8a25
movq %rax, %r14
movq %r15, 0x8(%rsp)
movq %rax, %r15
addq $0x30, %r15
incl %r12d
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x17660
movq %r15, 0x8(%r14)
movq %rbp, (%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r14)
movq $0x0, 0x28(%r14)
movl $0x1, 0x10(%r14)
movq %r14, %r12
movq %r15, %r13
leaq 0x1f0(%rbx), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2a5210
testq %rax, %rax
je 0x2a8a45
movq %rax, %r15
cmpq %r12, %rax
je 0x2a8a2f
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x2a8a18
orb $0x2, 0x40(%rsi)
movq %rbx, %rdi
callq 0x272447
movq $0x0, 0x28(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x28fc83
jmp 0x2a8a45
movq %rbx, %rdi
callq 0x278b1c
jmp 0x2a8a42
movq %rbx, %rdi
callq 0x278b1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x282904
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabBestIndex
static int pragmaVtabBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
  PragmaVtab *pTab = (PragmaVtab*)tab;
  const struct sqlite3_index_constraint *pConstraint;
  int i, j;
  int seen[2];

  pIdxInfo->estimatedCost = (double)1;
  if( pTab->nHidden==0 ){ return SQLITE_OK; }
  pConstraint = pIdxInfo->aConstraint;
  seen[0] = 0;
  seen[1] = 0;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    if( pConstraint->usable==0 ) continue;
    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( pConstraint->iColumn < pTab->iHidden ) continue;
    j = pConstraint->iColumn - pTab->iHidden;
    assert( j < 2 );
    seen[j] = i+1;
  }
  if( seen[0]==0 ){
    pIdxInfo->estimatedCost = (double)2147483647;
    pIdxInfo->estimatedRows = 2147483647;
    return SQLITE_OK;
  }
  j = seen[0]-1;
  pIdxInfo->aConstraintUsage[j].argvIndex = 1;
  pIdxInfo->aConstraintUsage[j].omit = 1;
  if( seen[1]==0 ) return SQLITE_OK;
  pIdxInfo->estimatedCost = (double)20;
  pIdxInfo->estimatedRows = 20;
  j = seen[1]-1;
  pIdxInfo->aConstraintUsage[j].argvIndex = 2;
  pIdxInfo->aConstraintUsage[j].omit = 1;
  return SQLITE_OK;
}

// Assembly:
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x40(%rsi)
cmpb $0x0, 0x28(%rdi)
je 0x2a8d1b
movq 0x8(%rsi), %rax
movq $0x0, -0x8(%rsp)
movl (%rsi), %ecx
testl %ecx, %ecx
jle 0x2a8d05
negl %ecx
addq $0x5, %rax
movl $0x1, %edx
cmpb $0x0, (%rax)
je 0x2a8ca8
cmpb $0x2, -0x1(%rax)
jne 0x2a8ca8
movslq -0x5(%rax), %r8
movzbl 0x29(%rdi), %r9d
cmpl %r9d, %r8d
jl 0x2a8ca8
subq %r9, %r8
movl %edx, -0x8(%rsp,%r8,4)
leal (%rcx,%rdx), %r8d
incl %r8d
incl %edx
addq $0xc, %rax
cmpl $0x1, %r8d
jne 0x2a8c87
movslq -0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x2a8d05
movq 0x20(%rsi), %rax
movl $0x1, -0x8(%rax,%rcx,8)
movb $0x1, -0x4(%rax,%rcx,8)
movslq -0x4(%rsp), %rcx
testq %rcx, %rcx
je 0x2a8d1b
movabsq $0x4034000000000000, %rdx # imm = 0x4034000000000000
movq %rdx, 0x40(%rsi)
movq $0x14, 0x48(%rsi)
movl $0x2, -0x8(%rax,%rcx,8)
movb $0x1, -0x4(%rax,%rcx,8)
jmp 0x2a8d1b
movabsq $0x41dfffffffc00000, %rax # imm = 0x41DFFFFFFFC00000
movq %rax, 0x40(%rsi)
movq $0x7fffffff, 0x48(%rsi) # imm = 0x7FFFFFFF
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabOpen
static int pragmaVtabOpen(sqlite3_vtab *pVtab, sqlite3_vtab_cursor **ppCursor){
  PragmaVtabCursor *pCsr;
  pCsr = (PragmaVtabCursor*)sqlite3_malloc(sizeof(*pCsr));
  if( pCsr==0 ) return SQLITE_NOMEM;
  memset(pCsr, 0, sizeof(PragmaVtabCursor));
  pCsr->base.pVtab = pVtab;
  *ppCursor = &pCsr->base;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2725a7
movl $0x7, %ebp
testl %eax, %eax
jne 0x2a8d62
movl $0x28, %edi
callq 0x272ae6
testq %rax, %rax
je 0x2a8d62
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %r14, (%rax)
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabClose
static int pragmaVtabClose(sqlite3_vtab_cursor *cur){
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)cur;
  pragmaVtabCursorClear(pCsr);
  sqlite3_free(pCsr);
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2a8fdc
movq %rbx, %rdi
callq 0x272c00
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabNext
static int pragmaVtabNext(sqlite3_vtab_cursor *pVtabCursor){
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
  int rc = SQLITE_OK;

  /* Increment the xRowid value */
  pCsr->iRowid++;
  assert( pCsr->pPragma );
  if( SQLITE_ROW!=sqlite3_step(pCsr->pPragma) ){
    rc = sqlite3_finalize(pCsr->pPragma);
    pCsr->pPragma = 0;
    pragmaVtabCursorClear(pCsr);
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq 0x10(%rdi)
movq 0x8(%rdi), %rdi
callq 0x278b63
cmpl $0x64, %eax
jne 0x2a8f54
xorl %eax, %eax
jmp 0x2a8f71
movq 0x8(%rbx), %rdi
callq 0x277e46
movl %eax, %ebp
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x2a8fdc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabColumn
static int pragmaVtabColumn(
  sqlite3_vtab_cursor *pVtabCursor,
  sqlite3_context *ctx,
  int i
){
  PragmaVtabCursor *pCsr = (PragmaVtabCursor*)pVtabCursor;
  PragmaVtab *pTab = (PragmaVtab*)(pVtabCursor->pVtab);
  if( i<pTab->iHidden ){
    sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pPragma, i));
  }else{
    sqlite3_result_text(ctx, pCsr->azArg[i-pTab->iHidden],-1,SQLITE_TRANSIENT);
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rax
movzbl 0x29(%rax), %eax
cmpl %eax, %edx
jge 0x2a8faa
movq 0x8(%rdi), %rdi
movl %edx, %esi
callq 0x279d43
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x278985
jmp 0x2a8fce
movslq %edx, %rcx
subq %rax, %rcx
movq 0x18(%rdi,%rcx,8), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x278487
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaVtabCursorClear
static void pragmaVtabCursorClear(PragmaVtabCursor *pCsr){
  int i;
  sqlite3_finalize(pCsr->pPragma);
  pCsr->pPragma = 0;
  for(i=0; i<ArraySize(pCsr->azArg); i++){
    sqlite3_free(pCsr->azArg[i]);
    pCsr->azArg[i] = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x277e46
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdi
callq 0x272c00
movq %r14, 0x18(%rbx)
movq 0x20(%rbx), %rdi
callq 0x272c00
movq %r14, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: addModuleArgument
static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){
  sqlite3_int64 nBytes = sizeof(char *)*(2+pTable->nModuleArg);
  char **azModuleArg;
  sqlite3 *db = pParse->db;
  if( pTable->nModuleArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
  }
  azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
  if( azModuleArg==0 ){
    sqlite3DbFree(db, zArg);
  }else{
    int i = pTable->nModuleArg++;
    azModuleArg[i] = zArg;
    azModuleArg[i+1] = 0;
    pTable->azModuleArg = azModuleArg;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movslq 0x54(%rsi), %rax
leaq 0x10(,%rax,8), %r12
movq (%rdi), %r15
addl $0x3, %eax
cmpl 0x84(%r15), %eax
jl 0x2a904f
movq (%r14), %rdx
leaq 0x12e253(%rip), %rsi    # 0x3d729b
xorl %eax, %eax
callq 0x27b48d
movq 0x58(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2829e5
testq %rax, %rax
je 0x2a908c
movslq 0x54(%r14), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x54(%r14)
movq %rbx, (%rax,%rcx,8)
movq $0x0, 0x8(%rax,%rcx,8)
movq %rax, 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rbx, %rbx
je 0x2a9080
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x282904
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CollapseDatabaseArray
SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){
  int i, j;
  for(i=j=2; i<db->nDb; i++){
    struct Db *pDb = &db->aDb[i];
    if( pDb->pBt==0 ){
      sqlite3DbFree(db, pDb->zDbSName);
      pDb->zDbSName = 0;
      continue;
    }
    if( j<i ){
      db->aDb[j] = db->aDb[i];
    }
    j++;
  }
  db->nDb = j;
  if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
    memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
    sqlite3DbFree(db, db->aDb);
    db->aDb = db->aDbStatic;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
jle 0x2a9130
movl $0x2, %ebp
movl $0x2, %r14d
movl $0x40, %r15d
movq 0x20(%rbx), %rax
leaq (%rax,%r15), %r12
cmpq $0x0, 0x8(%rax,%r15)
je 0x2a90fd
movslq %ebp, %rcx
cmpq %rcx, %r14
jle 0x2a90f9
shlq $0x5, %rcx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incl %ebp
jmp 0x2a9116
movq (%r12), %rsi
testq %rsi, %rsi
je 0x2a910e
movq %rbx, %rdi
callq 0x282904
movq $0x0, (%r12)
incq %r14
movslq 0x28(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r14
jl 0x2a90c9
movl %ebp, 0x28(%rbx)
cmpl $0x2, %ebp
jle 0x2a9137
jmp 0x2a9175
movl $0x2, 0x28(%rbx)
movq 0x20(%rbx), %rsi
leaq 0x268(%rbx), %r14
cmpq %r14, %rsi
je 0x2a9175
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x30(%rsi), %xmm3
movups %xmm3, 0x30(%r14)
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbx, %rdi
callq 0x282904
movq %r14, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DeleteColumnNames
SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3 *db, Table *pTable){
  int i;
  Column *pCol;
  assert( pTable!=0 );
  if( (pCol = pTable->aCol)!=0 ){
    for(i=0; i<pTable->nCol; i++, pCol++){
      assert( pCol->zName==0 || pCol->hName==sqlite3StrIHash(pCol->zName) );
      sqlite3DbFree(db, pCol->zName);
      sqlite3ExprDelete(db, pCol->pDflt);
      sqlite3DbFree(db, pCol->zColl);
    }
    sqlite3DbFree(db, pTable->aCol);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x2a93e6
movq %rsi, %r15
movq %rdi, %rbx
cmpw $0x0, 0x46(%rsi)
jle 0x2a93d1
xorl %ebp, %ebp
movq (%r14), %rsi
testq %rsi, %rsi
je 0x2a9397
movq %rbx, %rdi
callq 0x282904
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x2a93a8
movq %rbx, %rdi
callq 0x2a6164
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x2a93b9
movq %rbx, %rdi
callq 0x282904
incl %ebp
addq $0x20, %r14
movswl 0x46(%r15), %eax
cmpl %eax, %ebp
jl 0x2a9387
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x2a93e6
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x282904
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DeleteTriggerStep
SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
  while( pTriggerStep ){
    TriggerStep * pTmp = pTriggerStep;
    pTriggerStep = pTriggerStep->pNext;

    sqlite3ExprDelete(db, pTmp->pWhere);
    sqlite3ExprListDelete(db, pTmp->pExprList);
    sqlite3SelectDelete(db, pTmp->pSelect);
    sqlite3IdListDelete(db, pTmp->pIdList);
    sqlite3UpsertDelete(db, pTmp->pUpsert);
    sqlite3SrcListDelete(db, pTmp->pFrom);
    sqlite3DbFree(db, pTmp->zSpan);

    sqlite3DbFree(db, pTmp);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2a95ce
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%r14), %rsi
movq 0x50(%r14), %r15
testq %rsi, %rsi
je 0x2a9556
movq %rbx, %rdi
callq 0x2a6164
movq 0x30(%r14), %rsi
testq %rsi, %rsi
je 0x2a9567
movq %rbx, %rdi
callq 0x2a65a3
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x2a957d
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2a62e6
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x2a6536
movq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x2a95cf
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x2a63cf
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x2a95b2
movq %rbx, %rdi
callq 0x282904
movq %rbx, %rdi
movq %r14, %rsi
callq 0x282904
movq %r15, %r14
testq %r15, %r15
jne 0x2a9541
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3UpsertDelete
SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){
  if( p ){
    sqlite3ExprListDelete(db, p->pUpsertTarget);
    sqlite3ExprDelete(db, p->pUpsertTargetWhere);
    sqlite3ExprListDelete(db, p->pUpsertSet);
    sqlite3ExprDelete(db, p->pUpsertWhere);
    sqlite3DbFree(db, p);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2a9633
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x2a95ee
movq %r14, %rdi
callq 0x2a65a3
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2a95ff
movq %r14, %rdi
callq 0x2a6164
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2a9610
movq %r14, %rdi
callq 0x2a65a3
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2a9621
movq %r14, %rdi
callq 0x2a6164
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x282904
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a7d3d
movslq %eax, %rcx
addq %r15, %rcx
movslq 0xc(%rsp), %rdx
cmpq $0xb3, %rdx
je 0x2a9a74
leal -0x73(%rdx), %eax
cmpl $0x2f, %eax
ja 0x2a9ac0
movabsq $0xc00000000003, %rsi   # imm = 0xC00000000003
btq %rax, %rsi
jae 0x2a9ac0
movl $0x3b, %eax
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x3b, %edx
je 0x2a9aae
leaq 0x128834(%rip), %rax    # 0x3d2300
cmpw $0x3b, (%rax,%rdx,2)
movl $0x3b, %eax
cmovnel %edx, %eax
jmp 0x2a9ab3
// File: /workspace/github_c_makefile_star2_O3/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 (%rdi), %rdx
movq 0x8(%rdi), %r14
leaq 0x10(%rdi), %r15
cmpq %r15, %rdx
jbe 0x2abeb1
leaq -0x18(%rdx), %rax
movq %rax, (%rbx)
movzwl 0x2(%rdx), %esi
addq $0x8, %rdx
movq 0x8(%rbx), %rdi
callq 0x2abd7b
movq (%rbx), %rdx
jmp 0x2abe8f
leaq 0x12b68e(%rip), %rsi    # 0x3d7546
movq %r14, %rdi
xorl %eax, %eax
callq 0x27b48d
movq %r14, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BeginTransaction
SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
  sqlite3 *db;
  Vdbe *v;
  int i;

  assert( pParse!=0 );
  db = pParse->db;
  assert( db!=0 );
  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
    return;
  }
  v = sqlite3GetVdbe(pParse);
  if( !v ) return;
  if( type!=TK_DEFERRED ){
    for(i=0; i<db->nDb; i++){
      sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
      sqlite3VdbeUsesBtree(v, i);
    }
  }
  sqlite3VdbeAddOp0(v, OP_AutoCommit);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0x12a9f2(%rip), %rdx    # 0x3d6b55
movl $0x16, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2c37ba
testl %eax, %eax
je 0x2ac17f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x2bc630
testq %rax, %rax
je 0x2ac176
movq %rax, %rbx
cmpl $0x7, %r14d
je 0x2ac203
cmpl $0x0, 0x28(%r15)
jle 0x2ac203
xorl %ebp, %ebp
cmpl $0x9, %r14d
sete %bpl
incl %ebp
movl $0x8, %r12d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2, %esi
movl %r14d, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
orl %eax, 0xc8(%rbx)
cmpq $0x1, %r14
je 0x2ac1f3
movq (%rbx), %rcx
movq 0x20(%rcx), %rcx
movq (%rcx,%r12), %rcx
cmpb $0x0, 0x11(%rcx)
je 0x2ac1f3
orl %eax, 0xcc(%rbx)
incq %r14
movslq 0x28(%r15), %rax
addq $0x20, %r12
cmpq %rax, %r14
jl 0x2ac1b1
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a83e1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3EndTransaction
SQLITE_PRIVATE void sqlite3EndTransaction(Parse *pParse, int eType){
  Vdbe *v;
  int isRollback;

  assert( pParse!=0 );
  assert( pParse->db!=0 );
  assert( eType==TK_COMMIT || eType==TK_END || eType==TK_ROLLBACK );
  isRollback = eType==TK_ROLLBACK;
  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
       isRollback ? "ROLLBACK" : "COMMIT", 0, 0) ){
    return;
  }
  v = sqlite3GetVdbe(pParse);
  if( v ){
    sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
cmpl $0xc, %esi
sete %bpl
leaq 0x12e29e(%rip), %rax    # 0x3da4d4
leaq 0x12b4ee(%rip), %rdx    # 0x3d772b
cmoveq %rax, %rdx
movl $0x16, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2c37ba
testl %eax, %eax
je 0x2ac259
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
callq 0x2bc630
testq %rax, %rax
je 0x2ac254
movb %bpl, %bl
movq %rax, %rdi
movl $0x1, %esi
movl $0x1, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x2a83e1
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x48, %esi
callq 0x282a35
movq %rax, %rbx
testq %rax, %rax
je 0x2ad432
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x40(%rbx)
movb %bpl, (%rbx)
movw $0xffff, 0x32(%rbx)     # imm = 0xFFFF
movq (%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2b69c0
movq (%r14), %rax
movl 0x88(%rax), %edx
cmpl 0x28(%rbx), %edx
jge 0x2ad452
leaq 0x12ac84(%rip), %rsi    # 0x3d80aa
movq %r14, %rdi
xorl %eax, %eax
callq 0x27b48d
jmp 0x2ad452
testq %r12, %r12
je 0x2ad442
movq (%r14), %rdi
movq %r12, %rsi
callq 0x2a6164
testq %r15, %r15
je 0x2ad452
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2a6164
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movl %ecx, 0x10(%rsp)
movq (%rdi), %rdi
movl %ecx, %r13d
leaq 0x49(%r13), %rsi
callq 0x282a35
movq %rax, %r14
testq %rax, %rax
je 0x2ad53b
movq %rax, %r15
movb %bpl, (%r14)
movw $0x0, 0x1(%r14)
movl $0x800000, 0x4(%r14)    # imm = 0x800000
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
movq %rax, 0x2c(%r14)
addq $0x48, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movups %xmm0, 0x38(%r14)
movq %r15, 0x8(%r14)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x17660
movb $0x0, 0x48(%r14,%r13)
movzbl 0x48(%r14), %eax
leaq 0x123f48(%rip), %rcx    # 0x3d1440
cmpb $0x0, (%rax,%rcx)
jns 0x2ad51a
xorl %ecx, %ecx
cmpb $0x22, %al
sete %cl
shll $0x6, %ecx
orl $0x4800000, %ecx        # imm = 0x4800000
movl %ecx, 0x4(%r14)
movq %r15, %rdi
callq 0x2c981d
movl $0x1, 0x28(%r14)
cmpb $0x2, 0x11c(%rbx)
jb 0x2ad53b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b1eb3
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_O3/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 0x2ad57b
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x2c8f5f
testl %eax, %eax
je 0x2ad57b
movb $-0x59, (%r14)
orl %ebp, %eax
movl %eax, 0x4(%r14)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3AddNotNull
SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
  Table *p;
  Column *pCol;
  p = pParse->pNewTable;
  if( p==0 || NEVER(p->nCol<1) ) return;
  pCol = &p->aCol[p->nCol-1];
  pCol->notNull = (u8)onError;
  p->tabFlags |= TF_HasNotNull;

  /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
  ** on this column.  */
  if( pCol->colFlags & COLFLAG_UNIQUE ){
    Index *pIdx;
    for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
      assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
      if( pIdx->aiColumn[0]==p->nCol-1 ){
        pIdx->uniqNotNull = 1;
      }
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2ad5ab
movswq 0x46(%rdi), %rax
testq %rax, %rax
jle 0x2ad5ab
movq 0x8(%rdi), %rcx
decl %eax
shlq $0x5, %rax
movb %sil, 0x18(%rcx,%rax)
orb $0x8, 0x41(%rdi)
testb $0x8, 0x1c(%rcx,%rax)
jne 0x2ad5ac
retq
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2ad5ab
movq 0x8(%rax), %rcx
movswl (%rcx), %ecx
movswl 0x46(%rdi), %edx
decl %edx
cmpl %ecx, %edx
jne 0x2ad5ca
orb $0x8, 0x63(%rax)
movq 0x28(%rax), %rax
jmp 0x2ad5b0
// File: /workspace/github_c_makefile_star2_O3/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 0x2ae9fc
cmpb $0x1, 0x11c(%rbx)
je 0x2ae9fc
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 0x2ae9fc
movq 0x30(%r14), %rsi
callq 0x2b1a3f
movq %rax, 0x30(%r14)
cmpl $0x0, 0x68(%rbx)
je 0x2aea10
leaq 0x60(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b1ae1
testq %rdx, %rdx
je 0x2aea10
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2a6164
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2b1797
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %edx, %edx
movq %rsi, %rcx
movq %rdx, 0x58(%rcx)
orb $0x1, 0x5(%rcx)
movq %rcx, %rdx
movq 0x50(%rcx), %r8
incl %eax
movq %r8, %rcx
testq %r8, %r8
jne 0x2b1751
testb $0x4, 0x5(%rsi)
jne 0x2b1797
movq (%rdi), %rcx
movl 0x8c(%rcx), %ecx
testl %ecx, %ecx
setg %dl
cmpl %ecx, %eax
setge %al
andb %dl, %al
cmpb $0x1, %al
jne 0x2b1797
leaq 0x1274a5(%rip), %rsi    # 0x3d8c35
xorl %eax, %eax
jmp 0x27b48d
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b1a7e
movl (%rbx), %ecx
leal -0x1(%rcx), %eax
testl %eax, %ecx
jne 0x2b1a9b
movslq %ecx, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdx
addq $0x8, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2829e5
testq %rax, %rax
je 0x2b1ab6
movl (%rax), %ecx
jmp 0x2b1a98
movl $0x20, %esi
movq %r15, %rdi
callq 0x282a35
testq %rax, %rax
je 0x2b1ab6
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rax, %rbx
leal 0x1(%rcx), %eax
movl %eax, (%rbx)
movslq %ecx, %rax
leaq (%rax,%rax,2), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx,%rax,8)
movq %r14, 0x8(%rbx,%rax,8)
jmp 0x2b1ad8
testq %r14, %r14
je 0x2b1ac6
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a6164
testq %rbx, %rbx
je 0x2b1ad6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a65a3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x2b1b9c
movq %rdx, %rbx
movq %rsi, %r15
movslq (%rsi), %r14
addq $0x8, %r15
decq %r14
movq (%rdx), %r13
testq %r13, %r13
je 0x2b1b45
movl %ecx, 0xc(%rsp)
movl 0x8(%rbx), %ebp
movq %rdi, 0x10(%rsp)
movq (%rdi), %rdi
leaq 0x1(%rbp), %rsi
callq 0x282a35
testq %rax, %rax
je 0x2b1b4a
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x17660
movb $0x0, (%r12,%rbp)
jmp 0x2b1b4d
xorl %r12d, %r12d
jmp 0x2b1b56
xorl %r12d, %r12d
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %ecx
leaq (%r14,%r14,2), %r14
movq %r12, 0x8(%r15,%r14,8)
testl %ecx, %ecx
je 0x2b1b9c
movq %rdi, %r13
movq %r12, %rdi
callq 0x2c981d
cmpb $0x2, 0x11c(%r13)
jb 0x2b1b9c
movq %r13, %rdi
leaq (%r15,%r14,8), %rax
addq $0x8, %rax
movq (%rax), %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b1eb3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprListSetSpan
SQLITE_PRIVATE void sqlite3ExprListSetSpan(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to add the span. */
  const char *zStart,     /* Start of the span */
  const char *zEnd        /* End of the span */
){
  sqlite3 *db = pParse->db;
  assert( pList!=0 || db->mallocFailed!=0 );
  if( pList ){
    struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
    assert( pList->nExpr>0 );
    if( pItem->zEName==0 ){
      pItem->zEName = sqlite3DbSpanDup(db, zStart, zEnd);
      pItem->eEName = ENAME_SPAN;
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2b1bbf
movslq (%rsi), %rax
leaq (%rax,%rax,2), %rax
cmpq $0x0, -0x8(%rsi,%rax,8)
je 0x2b1bc0
retq
pushq %rbx
leaq (%rsi,%rax,8), %rbx
addq $-0x10, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x2c9873
movq %rax, 0x8(%rbx)
movb 0x11(%rbx), %al
andb $-0x4, %al
incb %al
movb %al, 0x11(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3Expr
SQLITE_PRIVATE Expr *sqlite3Expr(
  sqlite3 *db,            /* Handle for sqlite3DbMallocZero() (may be null) */
  int op,                 /* Expression opcode */
  const char *zToken      /* Token argument.  Might be NULL */
){
  Token x;
  x.z = zToken;
  x.n = sqlite3Strlen30(zToken);
  return sqlite3ExprAlloc(db, op, &x, 0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0x2b1c09
movq %rdx, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x2b1c0b
xorl %eax, %eax
leaq 0x8(%rsp), %rdx
movl %eax, 0x8(%rdx)
movq %r14, %rdi
movl %ebx, %esi
xorl %ecx, %ecx
callq 0x2b1c27
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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, %r15
movl %esi, %ebp
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
xorl %r12d, %r12d
testq %rdx, %rdx
je 0x2b1c72
cmpl $0x98, %ebp
jne 0x2b1c6b
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2b1c6b
leaq 0xc(%rsp), %rsi
callq 0x2a5fc5
testl %eax, %eax
jne 0x2b1c72
movl 0x8(%r15), %r12d
incl %r12d
movslq %r12d, %rsi
addq $0x48, %rsi
movq %r14, %rdi
callq 0x282a35
movq %rax, %r14
testq %rax, %rax
je 0x2b1d47
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movq $0x0, 0x40(%r14)
movb %bpl, (%r14)
movw $0xffff, 0x32(%r14)     # imm = 0xFFFF
testq %r15, %r15
je 0x2b1d3f
testl %r12d, %r12d
je 0x2b1ce8
movq %r14, %r12
addq $0x48, %r12
movq %r12, 0x8(%r14)
movl 0x8(%r15), %edx
testq %rdx, %rdx
je 0x2b1d06
movq (%r15), %rsi
movq %r12, %rdi
callq 0x17660
movl 0x8(%r15), %eax
jmp 0x2b1d08
movl 0xc(%rsp), %eax
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
shll $0x1c, %ecx
addl $0x10800400, %ecx       # imm = 0x10800400
movl %ecx, 0x4(%r14)
movl %eax, 0x8(%r14)
jmp 0x2b1d3f
xorl %eax, %eax
movb $0x0, (%r12,%rax)
testl %ebx, %ebx
je 0x2b1d3f
movzbl (%r12), %eax
leaq 0x11f723(%rip), %rcx    # 0x3d1440
cmpb $0x0, (%rax,%rcx)
jns 0x2b1d3f
xorl %ecx, %ecx
cmpb $0x22, %al
sete %cl
shll $0x6, %ecx
orl $0x4000000, %ecx        # imm = 0x4000000
movl %ecx, 0x4(%r14)
movq %r12, %rdi
callq 0x2c981d
movl $0x1, 0x28(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2b1d93
movl 0x8(%rdx), %eax
testl %eax, %eax
je 0x2b1d93
pushq %rbx
movslq (%rsi), %rcx
imulq $0x70, %rcx, %rcx
leaq (%rcx,%rsi), %rbx
addq $-0x68, %rbx
cmpl $0x1, %eax
jne 0x2b1d7e
cmpq $0x0, (%rdx)
je 0x2b1d94
movq (%rdi), %rdi
movq %rdx, %rsi
callq 0x2b1f02
movq %rax, 0x60(%rbx)
movb $0x2, %al
orb %al, 0x3d(%rbx)
popq %rbx
retq
movb $0x1, %al
jmp 0x2b1d8f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListFuncArgs
SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
  if( p ){
    struct SrcList_item *pItem = &p->a[p->nSrc-1];
    assert( pItem->fg.notIndexed==0 );
    assert( pItem->fg.isIndexedBy==0 );
    assert( pItem->fg.isTabFunc==0 );
    pItem->u1.pFuncArg = pList;
    pItem->fg.isTabFunc = 1;
  }else{
    sqlite3ExprListDelete(pParse->db, pList);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2b1daf
movslq (%rsi), %rax
imulq $0x70, %rax, %rax
movq %rdx, -0x8(%rax,%rsi)
orb $0x4, -0x2b(%rax,%rsi)
retq
testq %rdx, %rdx
je 0x2b1dbf
movq (%rdi), %rdi
movq %rdx, %rsi
jmp 0x2a65a3
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq (%rdi), %r15
testq %rsi, %rsi
je 0x2b1dfa
movq %rsi, %r13
movl (%rsi), %ecx
movl $0x1, %edx
callq 0x2d2b1e
testq %rax, %rax
je 0x2b1e99
movq %rax, %rbx
movslq (%rax), %rax
decq %rax
jmp 0x2b1e48
movl $0x78, %esi
movq %r15, %rdi
callq 0x282a35
testq %rax, %rax
je 0x2b1ea4
movq %rax, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0xffffffff, 0x48(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
imulq $0x70, %rax, %rax
leaq (%rbx,%rax), %r13
addq $0x8, %r13
testq %r12, %r12
je 0x2b1e80
cmpq $0x0, (%r12)
je 0x2b1e80
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b1f02
movq %rax, 0x10(%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b1f02
movq %rax, 0x8(%r13)
jmp 0x2b1ea6
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b1f02
movq %rax, 0x10(%r13)
movq $0x0, 0x8(%r13)
jmp 0x2b1ea6
movq %r15, %rdi
movq %r13, %rsi
callq 0x2a63cf
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2b1ef9
movq %rdx, %r15
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x20, %esi
callq 0x279b27
testq %rax, %rax
je 0x2b1ef9
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_O3/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 0x2b2e1b
movq %rdx, %rbx
movq %rdi, %r15
movl (%rdx), %edx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x2d2b1e
testq %rax, %rax
je 0x2b2e10
movq %rax, %r12
movq %rax, %rdi
addq $0x78, %rdi
leaq 0x8(%rbx), %rsi
movslq (%rbx), %rax
imulq $0x70, %rax, %rdx
callq 0x17660
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x282904
movq %r12, %r14
jmp 0x2b2e1b
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x2a63cf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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, %r14
testq %rdi, %rdi
je 0x2b65d3
movl $0x40, %esi
movq %r14, %rdi
callq 0x282a35
jmp 0x2b65dd
movl $0x40, %edi
callq 0x272ae6
movq %rax, %r12
testq %rax, %rax
je 0x2b6603
movq %rbp, (%r12)
movq %r13, 0x8(%r12)
movq %r15, 0x10(%r12)
movq %rbx, 0x18(%r12)
movq $0x0, 0x20(%r12)
jmp 0x2b6643
testq %rbp, %rbp
je 0x2b6613
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2a65a3
testq %r13, %r13
je 0x2b6623
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a6164
testq %r15, %r15
je 0x2b6633
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a65a3
testq %rbx, %rbx
je 0x2b6643
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a6164
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq