LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CheckObjectName
SQLITE_PRIVATE int sqlite3CheckObjectName(
  Parse *pParse,            /* Parsing context */
  const char *zName,        /* Name of the object to check */
  const char *zType,        /* Type of this object */
  const char *zTblName      /* Parent table name for triggers and indexes */
){
  sqlite3 *db = pParse->db;
  if( sqlite3WritableSchema(db)
   || db->init.imposterTable
   || !sqlite3Config.bExtraSchemaChecks
  ){
    /* Skip these error checks for writable_schema=ON */
    return SQLITE_OK;
  }
  if( db->init.busy ){
    if( sqlite3_stricmp(zType, db->init.azInit[0])
     || sqlite3_stricmp(zName, db->init.azInit[1])
     || sqlite3_stricmp(zTblName, db->init.azInit[2])
    ){
      sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
      return SQLITE_ERROR;
    }
  }else{
    if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
     || (sqlite3ReadOnlyShadowTables(db) && sqlite3ShadowTableName(db, zName))
    ){
      sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
                      zName);
      return SQLITE_ERROR;
    }

  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3e70c0
cmpl $0x0, %eax
jne 0x433ae0
movq -0x30(%rbp), %rax
movb 0xb6(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x433ae0
cmpb $0x0, 0x20bd7b(%rip)    # 0x63f859
jne 0x433aec
movl $0x0, -0x4(%rbp)
jmp 0x433bde
movq -0x30(%rbp), %rax
cmpb $0x0, 0xb5(%rax)
je 0x433b6c
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rax
movq (%rax), %rsi
callq 0x3c3e00
cmpl $0x0, %eax
jne 0x433b4f
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3c3e00
cmpl $0x0, %eax
jne 0x433b4f
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x3c3e00
cmpl $0x0, %eax
je 0x433b6a
movq -0x10(%rbp), %rdi
leaq 0x169ace(%rip), %rsi    # 0x59d628
movb $0x0, %al
callq 0x3cb660
movl $0x1, -0x4(%rbp)
jmp 0x433bde
jmp 0x433bd7
movq -0x10(%rbp), %rax
movzbl 0x1e(%rax), %eax
cmpl $0x0, %eax
jne 0x433b96
movq -0x18(%rbp), %rdi
leaq 0x1790e9(%rip), %rsi    # 0x5acc6d
movl $0x7, %edx
callq 0x3c3ef0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x433bb6
movq -0x30(%rbp), %rdi
callq 0x433d30
cmpl $0x0, %eax
je 0x433bd5
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x433d80
cmpl $0x0, %eax
je 0x433bd5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1790b0(%rip), %rsi    # 0x5acc75
movb $0x0, %al
callq 0x3cb660
movl $0x1, -0x4(%rbp)
jmp 0x433bde
jmp 0x433bd7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BeginWriteOperation
SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
  Parse *pToplevel = sqlite3ParseToplevel(pParse);
  sqlite3CodeVerifySchema(pParse, iDb);
  DbMaskSet(pToplevel->writeMask, iDb);
  pToplevel->isMultiWrite |= setStatement;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x433c21
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x433c29
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x431940
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
orl 0x70(%rax), %ecx
movl %ecx, 0x70(%rax)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movzbl 0x20(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3OpenSchemaTable
SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *p, int iDb){
  Vdbe *v = sqlite3GetVdbe(p);
  sqlite3TableLock(p, iDb, SCHEMA_ROOT, 1, DFLT_SCHEMA_TABLE);
  sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
  if( p->nTab==0 ){
    p->nTab = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4299d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %ecx
leaq 0x177d21(%rip), %r8     # 0x5ab9c0
movl %ecx, %edx
callq 0x429f80
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %r8d
movl $0x61, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x5, %r9d
callq 0x3cb970
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x433cda
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ReadOnlyShadowTables
SQLITE_PRIVATE int sqlite3ReadOnlyShadowTables(sqlite3 *db){
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( (db->flags & SQLITE_Defensive)!=0
   && db->pVtabCtx==0
   && db->nVdbeExec==0
  ){
    return 1;
  }
#endif
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x10000000, %rax       # imm = 0x10000000
cmpq $0x0, %rax
je 0x433d70
movq -0x10(%rbp), %rax
cmpq $0x0, 0x208(%rax)
jne 0x433d70
movq -0x10(%rbp), %rax
cmpl $0x0, 0xcc(%rax)
jne 0x433d70
movl $0x1, -0x4(%rbp)
jmp 0x433d77
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ShadowTableName
SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
  char *zTail;                  /* Pointer to the last "_" in zName */
  Table *pTab;                  /* Table that zName is a shadow of */
  zTail = strrchr(zName, '_');
  if( zTail==0 ) return 0;
  *zTail = 0;
  pTab = sqlite3FindTable(db, zName, 0);
  *zTail = '_';
  if( pTab==0 ) return 0;
  if( !IsVirtual(pTab) ) return 0;
  return sqlite3IsShadowTableOf(db, pTab, zName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x5f, %esi
callq 0x197d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x433db2
movl $0x0, -0x4(%rbp)
jmp 0x433e0c
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3d38b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb $0x5f, (%rax)
cmpq $0x0, -0x28(%rbp)
jne 0x433de5
movl $0x0, -0x4(%rbp)
jmp 0x433e0c
movq -0x28(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x433df8
movl $0x0, -0x4(%rbp)
jmp 0x433e0c
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x433e20
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IsShadowTableOf
SQLITE_PRIVATE int sqlite3IsShadowTableOf(sqlite3 *db, Table *pTab, const char *zName){
  int nName;                    /* Length of zName */
  Module *pMod;                 /* Module for the virtual table */

  if( !IsVirtual(pTab) ) return 0;
  nName = sqlite3Strlen30(pTab->zName);
  if( sqlite3_strnicmp(zName, pTab->zName, nName)!=0 ) return 0;
  if( zName[nName]!='_' ) return 0;
  pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]);
  if( pMod==0 ) return 0;
  if( pMod->pModule->iVersion<3 ) return 0;
  if( pMod->pModule->xShadowName==0 ) return 0;
  return pMod->pModule->xShadowName(zName+nName+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x433e4a
movl $0x0, -0x4(%rbp)
jmp 0x433f1a
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c3400
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl -0x24(%rbp), %edx
callq 0x3c3ef0
cmpl $0x0, %eax
je 0x433e7d
movl $0x0, -0x4(%rbp)
jmp 0x433f1a
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0x433e9a
movl $0x0, -0x4(%rbp)
jmp 0x433f1a
movq -0x10(%rbp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rsi
callq 0x40ad70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x433ec9
movl $0x0, -0x4(%rbp)
jmp 0x433f1a
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
jge 0x433ede
movl $0x0, -0x4(%rbp)
jmp 0x433f1a
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x433ef8
movl $0x0, -0x4(%rbp)
jmp 0x433f1a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0xb8(%rax), %rax
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rcx
addq %rcx, %rdi
addq $0x1, %rdi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResolveSelfReference
SQLITE_PRIVATE int sqlite3ResolveSelfReference(
  Parse *pParse,   /* Parsing context */
  Table *pTab,     /* The table being referenced, or NULL */
  int type,        /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */
  Expr *pExpr,     /* Expression to resolve.  May be NULL. */
  ExprList *pList  /* Expression list to resolve.  May be NULL. */
){
  SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
  NameContext sNC;                /* Name context for pParse->pNewTable */
  int rc;

  assert( type==0 || pTab!=0 );
  assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr
          || type==NC_GenCol || pTab==0 );
  memset(&sNC, 0, sizeof(sNC));
  memset(&sSrc, 0, sizeof(sSrc));
  if( pTab ){
    sSrc.nSrc = 1;
    sSrc.a[0].zName = pTab->zName;
    sSrc.a[0].pTab = pTab;
    sSrc.a[0].iCursor = -1;
    if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
      /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
      ** schema elements */
      type |= NC_FromDDL;
    }
  }
  sNC.pParse = pParse;
  sNC.pSrcList = &sSrc;
  sNC.ncFlags = type | NC_IsDDL;
  if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
  if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0xe0(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x19360
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x19360
cmpq $0x0, -0x18(%rbp)
je 0x4345e8
movl $0x1, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x38(%rcx), %rax
je 0x4345e6
movl -0x1c(%rbp), %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, -0x1c(%rbp)
jmp 0x4345e8
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xa8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0x1c(%rbp), %eax
orl $0x10000, %eax          # imm = 0x10000
movl %eax, -0xb8(%rbp)
movq -0x28(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x435380
movl %eax, -0xe4(%rbp)
cmpl $0x0, %eax
je 0x434635
movl -0xe4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43465b
cmpq $0x0, -0x30(%rbp)
je 0x434652
movq -0x30(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x4354b0
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResultSetOfSelect
SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, char aff){
  Table *pTab;
  sqlite3 *db = pParse->db;
  u64 savedFlags;

  savedFlags = db->flags;
  db->flags &= ~(u64)SQLITE_FullColNames;
  db->flags |= SQLITE_ShortColNames;
  sqlite3SelectPrep(pParse, pSelect, 0);
  db->flags = savedFlags;
  if( pParse->nErr ) return 0;
  while( pSelect->pPrior ) pSelect = pSelect->pPrior;
  pTab = sqlite3DbMallocZero(db, sizeof(Table) );
  if( pTab==0 ){
    return 0;
  }
  pTab->nTabRef = 1;
  pTab->zName = 0;
  pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
  sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
  sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect, aff);
  pTab->iPKey = -1;
  if( db->mallocFailed ){
    sqlite3DeleteTable(db, pTab);
    return 0;
  }
  return pTab;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
andq $-0x5, %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
orq $0x40, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x438710
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x434840
movq $0x0, -0x8(%rbp)
jmp 0x43490a
jmp 0x434842
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x43485b
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x434842
movq -0x30(%rbp), %rdi
movl $0x80, %esi
callq 0x3c9520
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x434881
movq $0x0, -0x8(%rbp)
jmp 0x43490a
movq -0x28(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movw $0xc8, 0x4a(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
addq $0x46, %rdx
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
callq 0x43af90
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsbl -0x19(%rbp), %ecx
callq 0x43b570
movq -0x28(%rbp), %rax
movw $0xffff, 0x44(%rax)     # imm = 0xFFFF
movq -0x30(%rbp), %rax
cmpb $0x0, 0x61(%rax)
je 0x434902
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3bff20
movq $0x0, -0x8(%rbp)
jmp 0x43490a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeEndCoroutine
SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
  sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);

  /* Clear the temporary register cache, thereby ensuring that each
  ** co-routine has its own independent set of registers, because co-routines
  ** might expect their registers to be preserved across an OP_Yield, and
  ** that could cause problems if two or more co-routines are using the same
  ** temporary register.
  */
  v->pParse->nTempReg = 0;
  v->pParse->nRangeReg = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x42, %esi
callq 0x42ba70
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, 0x1f(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl $0x0, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3NestedParse
SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
  va_list ap;
  char *zSql;
  char *zErrMsg = 0;
  sqlite3 *db = pParse->db;
  char saveBuf[PARSE_TAIL_SZ];

  if( pParse->nErr ) return;
  assert( pParse->nested<10 );  /* Nesting should only be of limited depth */
  va_start(ap, zFormat);
  zSql = sqlite3VMPrintf(db, zFormat, ap);
  va_end(ap);
  if( zSql==0 ){
    /* This can result either from an OOM or because the formatted string
    ** exceeds SQLITE_LIMIT_LENGTH.  In the latter case, we need to set
    ** an error */
    if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
    pParse->nErr++;
    return;
  }
  pParse->nested++;
  memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
  memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
  sqlite3RunParser(pParse, zSql, &zErrMsg);
  sqlite3DbFree(db, zErrMsg);
  sqlite3DbFree(db, zSql);
  memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
  pParse->nested--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
testb %al, %al
je 0x434da7
movaps %xmm0, -0x170(%rbp)
movaps %xmm1, -0x160(%rbp)
movaps %xmm2, -0x150(%rbp)
movaps %xmm3, -0x140(%rbp)
movaps %xmm4, -0x130(%rbp)
movaps %xmm5, -0x120(%rbp)
movaps %xmm6, -0x110(%rbp)
movaps %xmm7, -0x100(%rbp)
movq %r9, -0x178(%rbp)
movq %r8, -0x180(%rbp)
movq %rcx, -0x188(%rbp)
movq %rdx, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x434ded
jmp 0x434eec
leaq -0x30(%rbp), %rax
leaq -0x1a0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3da1d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
cmpq $0x0, -0x38(%rbp)
jne 0x434e58
movq -0x48(%rbp), %rax
cmpb $0x0, 0x61(%rax)
jne 0x434e46
movq -0x8(%rbp), %rax
movl $0x12, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0x434eec
movq -0x8(%rbp), %rax
movb 0x1e(%rax), %cl
addb $0x1, %cl
movb %cl, 0x1e(%rax)
leaq -0xf0(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x108, %rsi            # imm = 0x108
movl $0xa0, %edx
callq 0x19610
movq -0x8(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
xorl %esi, %esi
movl $0xa0, %edx
callq 0x19360
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x3cea20
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3c00a0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3c00a0
movq -0x8(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
leaq -0xf0(%rbp), %rsi
movl $0xa0, %edx
callq 0x19610
movq -0x8(%rbp), %rax
movb 0x1e(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1e(%rax)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ChangeCookie
SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
  sqlite3 *db = pParse->db;
  Vdbe *v = pParse->pVdbe;
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
                   (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movl (%rax), %r8d
addl $0x1, %r8d
movl $0x5e, %esi
movl $0x1, %ecx
callq 0x410130
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RenameTokenRemap
SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, void *pTo, void *pFrom){
  RenameToken *p;
  renameTokenCheckAll(pParse, pTo);
  for(p=pParse->pRename; p; p=p->pNext){
    if( p->p==pFrom ){
      p->p = pTo;
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1a0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x435060
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x435050
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x435060
jmp 0x435052
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x43502f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: isDupColumn
static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
  int i, j;
  assert( nKey<=pIdx->nColumn );
  assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
  assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
  assert( pPk->pTable->tabFlags & TF_WithoutRowid );
  assert( pPk->pTable==pIdx->pTable );
  testcase( pPk==pIdx );
  j = pPk->aiColumn[iCol];
  assert( j!=XN_ROWID && j!=XN_EXPR );
  for(i=0; i<nKey; i++){
    assert( pIdx->aiColumn[i]>=0 || j>=0 );
    if( pIdx->aiColumn[i]==j
     && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4350fd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl -0x2c(%rbp), %eax
jne 0x4350f0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3c3e60
cmpl $0x0, %eax
jne 0x4350f0
movl $0x1, -0x4(%rbp)
jmp 0x435104
jmp 0x4350f2
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4350a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: hasColumn
static int hasColumn(const i16 *aiCol, int nCol, int x){
  while( nCol-- > 0 ){
    assert( aiCol[0]>=0 );
    if( x==*(aiCol++) ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x4352c2
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x2, %rdx
movq %rdx, -0x10(%rbp)
movswl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x4352c0
movl $0x1, -0x4(%rbp)
jmp 0x4352c9
jmp 0x43528e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: recomputeColumnsNotIndexed
static void recomputeColumnsNotIndexed(Index *pIdx){
  Bitmask m = 0;
  int j;
  Table *pTab = pIdx->pTable;
  for(j=pIdx->nColumn-1; j>=0; j--){
    int x = pIdx->aiColumn[j];
    if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
      testcase( x==BMS-1 );
      testcase( x==BMS-2 );
      if( x<BMS-1 ) m |= MASKBIT(x);
    }
  }
  pIdx->colNotIdxed = ~m;
  assert( (pIdx->colNotIdxed>>63)==1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x60(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x435362
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x435355
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movzwl 0x1c(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x435355
cmpl $0x3f, -0x24(%rbp)
jge 0x435353
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x435355
jmp 0x435357
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4352fa
movq -0x10(%rbp), %rcx
xorq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResolveExprNames
SQLITE_PRIVATE int sqlite3ResolveExprNames(
  NameContext *pNC,       /* Namespace to resolve expressions in. */
  Expr *pExpr             /* The expression to be analyzed. */
){
  int savedHasAgg;
  Walker w;

  if( pExpr==0 ) return SQLITE_OK;
  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  w.pParse = pNC->pParse;
  w.xExprCallback = resolveExprStep;
  w.xSelectCallback = resolveSelectStep;
  w.xSelectCallback2 = 0;
  w.u.pNC = pNC;
#if SQLITE_MAX_EXPR_DEPTH>0
  w.pParse->nHeight += pExpr->nHeight;
  if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
    return SQLITE_ERROR;
  }
#endif
  sqlite3WalkExpr(&w, pExpr);
#if SQLITE_MAX_EXPR_DEPTH>0
  w.pParse->nHeight -= pExpr->nHeight;
#endif
  assert( EP_Agg==NC_HasAgg );
  assert( EP_Win==NC_HasWin );
  testcase( pNC->ncFlags & NC_HasAgg );
  testcase( pNC->ncFlags & NC_HasWin );
  ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
  pNC->ncFlags |= savedHasAgg;
  return pNC->nErr>0 || w.pParse->nErr>0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4353a3
movl $0x0, -0x4(%rbp)
jmp 0x43549d
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x9010, %eax           # imm = 0x9010
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
andl $0xffff6fef, %ecx       # imm = 0xFFFF6FEF
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq 0x28c(%rip), %rax       # 0x435660
movq %rax, -0x48(%rbp)
leaq 0xe71(%rip), %rax       # 0x436250
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x50(%rbp), %rax
addl 0x124(%rax), %ecx
movl %ecx, 0x124(%rax)
movq -0x50(%rbp), %rdi
movq -0x50(%rbp), %rax
movl 0x124(%rax), %esi
callq 0x436980
cmpl $0x0, %eax
je 0x43542b
movl $0x1, -0x4(%rbp)
jmp 0x43549d
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x42f650
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x50(%rbp), %rax
movl 0x124(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x124(%rax)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
andl $0x8010, %ecx           # imm = 0x8010
movq -0x18(%rbp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
orl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x24(%rcx)
movb %al, -0x51(%rbp)
jg 0x435492
movq -0x50(%rbp), %rax
cmpl $0x0, 0x30(%rax)
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: notValidImpl
static void notValidImpl(
   Parse *pParse,       /* Leave error message here */
   NameContext *pNC,    /* The name context */
   const char *zMsg,    /* Type of error */
   Expr *pExpr          /* Invalidate this expression on error */
){
  const char *zIn = "partial index WHERE clauses";
  if( pNC->ncFlags & NC_IdxExpr )      zIn = "index expressions";
#ifndef SQLITE_OMIT_CHECK
  else if( pNC->ncFlags & NC_IsCheck ) zIn = "CHECK constraints";
#endif
#ifndef SQLITE_OMIT_GENERATED_COLUMNS
  else if( pNC->ncFlags & NC_GenCol ) zIn = "generated columns";
#endif
  sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
  if( pExpr ) pExpr->op = TK_NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x17654a(%rip), %rax    # 0x5acf49
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x436a1f
leaq 0x17654c(%rip), %rax    # 0x5acf65
movq %rax, -0x28(%rbp)
jmp 0x436a59
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x436a3b
leaq 0x176542(%rip), %rax    # 0x5acf77
movq %rax, -0x28(%rbp)
jmp 0x436a57
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x436a55
leaq 0x176538(%rip), %rax    # 0x5acf89
movq %rax, -0x28(%rbp)
jmp 0x436a57
jmp 0x436a59
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x17652f(%rip), %rsi    # 0x5acf9b
movb $0x0, %al
callq 0x3cb660
cmpq $0x0, -0x20(%rbp)
je 0x436a81
movq -0x20(%rbp), %rax
movb $0x77, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprProbability
static int exprProbability(Expr *p){
  double r = -1.0;
  if( p->op!=TK_FLOAT ) return -1;
  sqlite3AtoF(p->u.zToken, &r, sqlite3Strlen30(p->u.zToken), SQLITE_UTF8);
  assert( r>=0.0 );
  if( r>1.0 ) return -1;
  return (int)(r*134217728.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd 0x105c1c(%rip), %xmm0   # 0x53d410
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x96, %eax
je 0x437810
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43786d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c3400
movq -0x20(%rbp), %rdi
movl %eax, %edx
leaq -0x18(%rbp), %rsi
movl $0x1, %ecx
callq 0x3ef260
movsd -0x18(%rbp), %xmm0
movsd 0xdf9f6(%rip), %xmm1    # 0x517240
ucomisd %xmm1, %xmm0
jbe 0x437859
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43786d
movsd 0x17340f(%rip), %xmm0   # 0x5aac70
mulsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FunctionUsesThisSrc
SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr *pExpr, SrcList *pSrcList){
  Walker w;
  struct SrcCount cnt;
  assert( pExpr->op==TK_AGG_FUNCTION );
  memset(&w, 0, sizeof(w));
  w.xExprCallback = exprSrcCount;
  w.xSelectCallback = selectSrcCount;
  w.u.pSrcCount = &cnt;
  cnt.pSrc = pSrcList;
  cnt.iSrcInner = (pSrcList&&pSrcList->nSrc)?pSrcList->a[0].iCursor:0x7FFFFFFF;
  cnt.nThis = 0;
  cnt.nOther = 0;
  sqlite3WalkExprList(&w, pExpr->x.pList);
#ifndef SQLITE_OMIT_WINDOWFUNC
  if( ExprHasProperty(pExpr, EP_WinFunc) ){
    sqlite3WalkExpr(&w, pExpr->y.pWin->pFilter);
  }
#endif
  return cnt.nThis>0 || cnt.nOther==0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19360
leaq 0xa09(%rip), %rax       # 0x4385d0
movq %rax, -0x38(%rbp)
leaq 0xade(%rip), %rax       # 0x4386b0
movq %rax, -0x30(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x437c02
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x437c02
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x437c0c
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0x5c(%rbp)
jmp 0x437c0c
movl -0x5c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x42f8b0
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x437c57
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x48(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x42f650
movb $0x1, %al
cmpl $0x0, -0x4c(%rbp)
movb %al, -0x5d(%rbp)
jg 0x437c6c
cmpl $0x0, -0x48(%rbp)
sete %al
movb %al, -0x5d(%rbp)
movb -0x5d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3MatchEName
SQLITE_PRIVATE int sqlite3MatchEName(
  const struct ExprList_item *pItem,
  const char *zCol,
  const char *zTab,
  const char *zDb
){
  int n;
  const char *zSpan;
  if( pItem->eEName!=ENAME_TAB ) return 0;
  zSpan = pItem->zEName;
  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
  if( zDb && (sqlite3StrNICmp(zSpan, zDb, n)!=0 || zDb[n]!=0) ){
    return 0;
  }
  zSpan += n+1;
  for(n=0; ALWAYS(zSpan[n]) && zSpan[n]!='.'; n++){}
  if( zTab && (sqlite3StrNICmp(zSpan, zTab, n)!=0 || zTab[n]!=0) ){
    return 0;
  }
  zSpan += n+1;
  if( zCol && sqlite3StrICmp(zSpan, zCol)!=0 ){
    return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x11(%rax), %al
andb $0x3, %al
movzbl %al, %eax
cmpl $0x2, %eax
je 0x437cb5
movl $0x0, -0x4(%rbp)
jmp 0x437e11
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x437cf3
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x437cfc
jmp 0x437d09
jmp 0x437cfe
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x437cc8
cmpq $0x0, -0x28(%rbp)
je 0x437d42
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x3c3ef0
cmpl $0x0, %eax
jne 0x437d36
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x437d42
movl $0x0, -0x4(%rbp)
jmp 0x437e11
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x437d88
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x437d91
jmp 0x437d9e
jmp 0x437d93
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x437d5d
cmpq $0x0, -0x20(%rbp)
je 0x437dd4
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x3c3ef0
cmpl $0x0, %eax
jne 0x437dcb
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x437dd4
movl $0x0, -0x4(%rbp)
jmp 0x437e11
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x437e0a
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c3e60
cmpl $0x0, %eax
je 0x437e0a
movl $0x0, -0x4(%rbp)
jmp 0x437e11
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3StrIHash
SQLITE_PRIVATE u8 sqlite3StrIHash(const char *z){
  u8 h = 0;
  if( z==0 ) return 0;
  while( z[0] ){
    h += UpperToLower[(unsigned char)z[0]];
    z++;
  }
  return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x437e39
movb $0x0, -0x1(%rbp)
jmp 0x437e75
jmp 0x437e3b
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x437e6f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x16ec0c(%rip), %rax    # 0x5a6a60
movzbl (%rax,%rcx), %ecx
movzbl -0x11(%rbp), %eax
addl %ecx, %eax
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x437e3b
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: areDoubleQuotedStringsEnabled
static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){
  if( db->init.busy ) return 1;  /* Always support for legacy schemas */
  if( pTopNC->ncFlags & NC_IsDDL ){
    /* Currently parsing a DDL statement */
    if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
      return 1;
    }
    return (db->flags & SQLITE_DqsDDL)!=0;
  }else{
    /* Currently parsing a DML statement */
    return (db->flags & SQLITE_DqsDML)!=0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0xb5(%rax)
je 0x438096
movl $0x1, -0x4(%rbp)
jmp 0x43810e
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x4380f1
movq -0x10(%rbp), %rdi
callq 0x3e70c0
cmpl $0x0, %eax
je 0x4380d2
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
je 0x4380d2
movl $0x1, -0x4(%rbp)
jmp 0x43810e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x43810e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x40000000, %rax       # imm = 0x40000000
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprColUsed
SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
  int n;
  Table *pExTab;

  n = pExpr->iColumn;
  pExTab = pExpr->y.pTab;
  assert( pExTab!=0 );
  if( (pExTab->tabFlags & TF_HasGenerated)!=0
   && (pExTab->aCol[n].colFlags & COLFLAG_GENERATED)!=0
  ){
    testcase( pExTab->nCol==BMS-1 );
    testcase( pExTab->nCol==BMS );
    return pExTab->nCol>=BMS ? ALLBITS : MASKBIT(pExTab->nCol)-1;
  }else{
    testcase( n==BMS-1 );
    testcase( n==BMS );
    if( n>=BMS ) n = BMS-1;
    return ((Bitmask)1)<<n;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x60, %eax
cmpl $0x0, %eax
je 0x4381ad
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movzwl 0x1c(%rax), %eax
andl $0x60, %eax
cmpl $0x0, %eax
je 0x4381ad
movq -0x20(%rbp), %rax
movswl 0x46(%rax), %eax
cmpl $0x40, %eax
jl 0x438187
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4381a3
movq -0x20(%rbp), %rax
movswl 0x46(%rax), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4381cb
cmpl $0x40, -0x14(%rbp)
jl 0x4381ba
movl $0x3f, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: incrAggFunctionDepth
static void incrAggFunctionDepth(Expr *pExpr, int N){
  if( N>0 ){
    Walker w;
    memset(&w, 0, sizeof(w));
    w.xExprCallback = incrAggDepth;
    w.u.n = N;
    sqlite3WalkExpr(&w, pExpr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4383a3
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19360
leaq 0x64(%rip), %rax        # 0x4383f0
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x42f650
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3AuthReadCol
SQLITE_PRIVATE int sqlite3AuthReadCol(
  Parse *pParse,                  /* The parser context */
  const char *zTab,               /* Table name */
  const char *zCol,               /* Column name */
  int iDb                         /* Index of containing database. */
){
  sqlite3 *db = pParse->db;          /* Database handle */
  char *zDb = db->aDb[iDb].zDbSName; /* Schema name of attached database */
  int rc;                            /* Auth callback return code */

  if( db->init.busy ) return SQLITE_OK;
  rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
#ifdef SQLITE_USER_AUTHENTICATION
                 ,db->auth.zAuthUser
#endif
                );
  if( rc==SQLITE_DENY ){
    char *z = sqlite3_mprintf("%s.%s", zTab, zCol);
    if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
    sqlite3ErrorMsg(pParse, "access to %z is prohibited", z);
    pParse->rc = SQLITE_AUTH;
  }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
    sqliteAuthBadReturnCode(pParse);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, 0xb5(%rax)
je 0x438485
movl $0x0, -0x4(%rbp)
jmp 0x438546
movq -0x30(%rbp), %rax
movq 0x1c8(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x1d0(%rcx), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x160(%rsi), %r9
movl $0x14, %esi
callq *%rax
movl %eax, -0x3c(%rbp)
cmpl $0x1, -0x3c(%rbp)
jne 0x438529
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0xed6f4(%rip), %rdi     # 0x525bc5
movb $0x0, %al
callq 0x3c3780
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jg 0x4384ec
cmpl $0x0, -0x24(%rbp)
je 0x438506
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq 0x174b5c(%rip), %rdi    # 0x5ad057
movb $0x0, %al
callq 0x3c3780
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x174b48(%rip), %rsi    # 0x5ad05d
movb $0x0, %al
callq 0x3cb660
movq -0x10(%rbp), %rax
movl $0x17, 0x18(%rax)
jmp 0x438540
cmpl $0x2, -0x3c(%rbp)
je 0x43853e
cmpl $0x0, -0x3c(%rbp)
je 0x43853e
movq -0x10(%rbp), %rdi
callq 0x4339a0
jmp 0x438540
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: windowFind
static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
  Window *p;
  for(p=pList; p; p=p->pNextWin){
    if( sqlite3StrICmp(p->zName, zName)==0 ) break;
  }
  if( p==0 ){
    sqlite3ErrorMsg(pParse, "no such window: %s", zName);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x43859a
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c3e60
cmpl $0x0, %eax
jne 0x43858a
jmp 0x43859a
jmp 0x43858c
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x43856c
cmpq $0x0, -0x20(%rbp)
jne 0x4385b7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x174b4e(%rip), %rsi    # 0x5ad0fe
movb $0x0, %al
callq 0x3cb660
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprSrcCount
static int exprSrcCount(Walker *pWalker, Expr *pExpr){
  /* There was once a NEVER() on the second term on the grounds that
  ** sqlite3FunctionUsesThisSrc() was always called before
  ** sqlite3ExprAnalyzeAggregates() and so the TK_COLUMNs have not yet
  ** been converted into TK_AGG_COLUMN. But this is no longer true due
  ** to window functions - sqlite3WindowRewrite() may now indirectly call
  ** FunctionUsesThisSrc() when creating a new sub-select. */
  if( pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN ){
    int i;
    struct SrcCount *p = pWalker->u.pSrcCount;
    SrcList *pSrc = p->pSrc;
    int nSrc = pSrc ? pSrc->nSrc : 0;
    for(i=0; i<nSrc; i++){
      if( pExpr->iTable==pSrc->a[i].iCursor ) break;
    }
    if( i<nSrc ){
      p->nThis++;
    }else if( pExpr->iTable<p->iSrcInner ){
      /* In a well-formed parse tree (no name resolution errors),
      ** TK_COLUMN nodes with smaller Expr.iTable values are in an
      ** outer context.  Those are the only ones to count as "other" */
      p->nOther++;
    }
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa4, %eax
je 0x4385fc
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa6, %eax
jne 0x4386a7
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x438625
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x43862c
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x43862c
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x43866f
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movslq -0x14(%rbp), %rdx
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x40(%rcx), %eax
jne 0x438662
jmp 0x43866f
jmp 0x438664
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x438639
movl -0x14(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x438686
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x4386a5
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4386a3
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x4386a5
jmp 0x4386a7
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: selectSrcCount
static int selectSrcCount(Walker *pWalker, Select *pSel){
  struct SrcCount *p = pWalker->u.pSrcCount;
  if( p->iSrcInner==0x7FFFFFFF && ALWAYS(pSel->pSrc) && pSel->pSrc->nSrc ){
    pWalker->u.pSrcCount->iSrcInner = pSel->pSrc->a[0].iCursor;
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x7fffffff, 0x8(%rax)  # imm = 0x7FFFFFFF
jne 0x438703
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x438703
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, (%rax)
je 0x438703
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x48(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl %ecx, 0x8(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)