LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3TwoPartName
SQLITE_PRIVATE int sqlite3TwoPartName(
  Parse *pParse,      /* Parsing and code generating context */
  Token *pName1,      /* The "xxx" in the name "xxx.yyy" or "xxx" */
  Token *pName2,      /* The "yyy" in the name "xxx.yyy" */
  Token **pUnqual     /* Write the unqualified object name here */
){
  int iDb;                    /* Database holding the object */
  sqlite3 *db = pParse->db;

  assert( pName2!=0 );
  if( pName2->n>0 ){
    if( db->init.busy ) {
      sqlite3ErrorMsg(pParse, "corrupt database");
      return -1;
    }
    *pUnqual = pName2;
    iDb = sqlite3FindDb(db, pName1);
    if( iDb<0 ){
      sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
      return -1;
    }
  }else{
    assert( db->init.iDb==0 || db->init.busy || IN_RENAME_OBJECT
             || (db->mDbFlags & DBFLAG_Vacuum)!=0);
    iDb = db->init.iDb;
    *pUnqual = pName1;
  }
  return iDb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x8(%rdx)
je 0x2ccf97
cmpb $0x0, 0xb5(%rdi)
je 0x2ccfa3
leaq 0x113f7d(%rip), %rsi    # 0x3e0f03
movq %rbx, %rdi
xorl %eax, %eax
callq 0x284eb8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2ccfb2
movzbl 0xb4(%rdi), %eax
movq %r14, (%rcx)
jmp 0x2ccfb2
movq %rdx, (%rcx)
movq %r14, %rsi
callq 0x2cd207
testl %eax, %eax
js 0x2ccfba
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x113f53(%rip), %rsi    # 0x3e0f14
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x284eb8
jmp 0x2ccf90
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
movq 0x30(%r12), %r13
movl %r13d, %eax
andl $0x10000001, %eax       # imm = 0x10000001
xorl %ebx, %ebx
cmpl $0x1, %eax
je 0x2cd150
testb $0x2, 0xb6(%r12)
jne 0x2cd150
cmpb $0x0, 0x1f965f(%rip)    # 0x4c6669
je 0x2cd150
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x0, 0xb5(%r12)
je 0x2cd073
movq 0xb8(%r12), %rax
movq (%rax), %rsi
testq %rdx, %rdx
je 0x2cd0e4
testq %rsi, %rsi
je 0x2cd13a
xorl %edi, %edi
leaq 0x10da19(%rip), %r8     # 0x3daa60
movzbl (%rdx,%rdi), %r9d
movzbl (%rsi,%rdi), %r10d
cmpb %r10b, %r9b
jne 0x2cd060
testq %r9, %r9
jne 0x2cd06e
jmp 0x2cd0e9
movb (%r9,%r8), %r9b
cmpb (%r10,%r8), %r9b
jne 0x2cd13a
incq %rdi
jmp 0x2cd047
cmpb $0x0, 0x1e(%r14)
jne 0x2cd092
leaq 0x113ea7(%rip), %rsi    # 0x3e0f28
movq %r15, %rdi
movl $0x7, %edx
callq 0x27e951
testl %eax, %eax
je 0x2cd0ce
btl $0x1c, %r13d
jae 0x2cd150
cmpq $0x0, 0x208(%r12)
jne 0x2cd150
cmpl $0x0, 0xcc(%r12)
jne 0x2cd150
movq %r12, %rdi
movq %r15, %rsi
callq 0x2cd23a
testl %eax, %eax
je 0x2cd150
leaq 0x113e5b(%rip), %rsi    # 0x3e0f30
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x284eb8
jmp 0x2cd14b
testq %rsi, %rsi
jne 0x2cd13a
movq 0x8(%rax), %rdx
testq %r15, %r15
je 0x2cd125
testq %rdx, %rdx
je 0x2cd13a
xorl %esi, %esi
leaq 0x10d960(%rip), %rdi    # 0x3daa60
movzbl (%r15,%rsi), %r8d
movzbl (%rdx,%rsi), %r9d
cmpb %r9b, %r8b
jne 0x2cd116
testq %r8, %r8
jne 0x2cd120
jmp 0x2cd12a
movb (%r8,%rdi), %r8b
cmpb (%r9,%rdi), %r8b
jne 0x2cd13a
incq %rsi
jmp 0x2cd100
testq %rdx, %rdx
jne 0x2cd13a
movq 0x10(%rax), %rsi
movq %rcx, %rdi
callq 0x27e905
testl %eax, %eax
je 0x2cd150
leaq 0x10674f(%rip), %rsi    # 0x3d3890
movq %r14, %rdi
xorl %eax, %eax
callq 0x284eb8
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq 0xa0(%rdi), %r14
testq %r14, %r14
cmoveq %rdi, %r14
movl %edx, %esi
callq 0x2cbe18
movl $0x1, %eax
movl %ebx, %ecx
shll %cl, %eax
orl %eax, 0x70(%r14)
orb %bpl, 0x20(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2c5ddf
movq %rax, %r14
leaq 0x112ad9(%rip), %r8     # 0x3dfc80
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x2c60e2
movq %r14, %rdi
movl $0x61, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x2b200c
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
jne 0x2cd1f5
movq 0x88(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
movb $-0x3, 0x1(%rcx,%rax,8)
movl $0x5, 0x10(%rcx,%rax,8)
cmpl $0x0, 0x34(%rbx)
jne 0x2cd202
movl $0x1, 0x34(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x5f, %esi
callq 0x17880
testq %rax, %rax
je 0x2cd289
movq %rax, %r15
movb $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x28ad59
movb $0x5f, (%r15)
testq %rax, %rax
je 0x2cd289
cmpl $0x0, 0x54(%rax)
je 0x2cd289
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2cd291
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x0, 0x54(%rsi)
je 0x2cd331
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
testq %r12, %r12
je 0x2cd2c9
movq %r12, %rdi
callq 0x172f0
movq %rax, %r13
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
jmp 0x2cd2cc
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x27e951
testl %eax, %eax
jne 0x2cd331
movl %r13d, %r12d
cmpb $0x5f, (%rbx,%r12)
jne 0x2cd331
addq $0x1f0, %r14            # imm = 0x1F0
movq 0x58(%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2aefdf
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2cd331
movq (%rax), %rax
cmpl $0x3, (%rax)
jl 0x2cd331
movq 0xb8(%rax), %rax
testq %rax, %rax
je 0x2cd331
addq %r12, %rbx
incq %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %rbx
subq $0xc0, %rsp
movq %r8, %rbx
xorl %eax, %eax
movq %rax, 0xb0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movq %rax, 0x70(%rsp)
testq %rsi, %rsi
je 0x2cd8db
movl $0x1, (%rsp)
movq (%rsi), %rax
movq %rax, 0x18(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xffffffff, 0x48(%rsp) # imm = 0xFFFFFFFF
movq 0x70(%rsi), %rax
movq (%rdi), %rsi
movq 0x20(%rsi), %rsi
movl %edx, %r8d
orl $0x40000, %r8d          # imm = 0x40000
cmpq 0x38(%rsi), %rax
cmovnel %r8d, %edx
leaq 0x80(%rsp), %rax
movq %rdi, (%rax)
movq %rsp, %rsi
movq %rsi, 0x8(%rax)
orl $0x10000, %edx          # imm = 0x10000
movl %edx, 0x28(%rax)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x2ce0ea
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x2cd925
testq %rbx, %rbx
je 0x2cd923
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0x2ce1c1
jmp 0x2cd925
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x30(%rbx), %r12
movq %r12, %rax
andq $-0x45, %rax
orq $0x40, %rax
movq %rax, 0x30(%rbx)
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x2d0563
movq %r12, 0x30(%rbx)
cmpl $0x0, 0x30(%r14)
jne 0x2cda38
movq %r13, %r12
movq 0x50(%r13), %r13
testq %r13, %r13
jne 0x2cd9be
movl $0x80, %esi
movq %rbx, %rdi
callq 0x283569
testq %rax, %rax
je 0x2cda35
movq %rax, %r15
movl $0x1, 0x3c(%rax)
movq $0x0, (%rax)
movw $0xc8, 0x4a(%rax)
movq 0x20(%r12), %rsi
leaq 0x46(%rax), %rdx
movq %rax, %rcx
addq $0x8, %rcx
movq %r14, %rdi
callq 0x2d24b3
movsbl %bpl, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2d2836
movw $0xffff, 0x44(%r15)     # imm = 0xFFFF
cmpb $0x0, 0x61(%rbx)
je 0x2cda38
movq %rbx, %rdi
movq %r15, %rsi
callq 0x27bd74
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3TableAffinity
SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
  int i, j;
  char *zColAff = pTab->zColAff;
  if( zColAff==0 ){
    sqlite3 *db = sqlite3VdbeDb(v);
    zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
    if( !zColAff ){
      sqlite3OomFault(db);
      return;
    }

    for(i=j=0; i<pTab->nCol; i++){
      assert( pTab->aCol[i].affinity!=0 );
      if( (pTab->aCol[i].colFlags & COLFLAG_VIRTUAL)==0 ){
        zColAff[j++] = pTab->aCol[i].affinity;
      }
    }
    do{
      zColAff[j--] = 0;
    }while( j>=0 && zColAff[j]<=SQLITE_AFF_BLOB );
    pTab->zColAff = zColAff;
  }
  assert( zColAff!=0 );
  i = sqlite3Strlen30NN(zColAff);
  if( i ){
    if( iReg ){
      sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
    }else{
      sqlite3VdbeChangeP4(v, -1, zColAff, i);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movq 0x28(%rsi), %r14
testq %r14, %r14
jne 0x2cdae4
movq %rsi, %r15
movq (%rbx), %r12
movswq 0x46(%rsi), %rdi
incq %rdi
callq 0x27c381
movq %rax, %r14
testq %rax, %rax
je 0x2cdad7
xorl %eax, %eax
cmpw $0x0, 0x46(%r15)
jle 0x2cdabb
movl $0x1c, %ecx
xorl %edx, %edx
movq 0x8(%r15), %rsi
testb $0x20, (%rsi,%rcx)
jne 0x2cdaa8
movb -0x3(%rsi,%rcx), %sil
movslq %eax, %rdi
incl %eax
movb %sil, (%r14,%rdi)
incq %rdx
movswq 0x46(%r15), %rsi
addq $0x20, %rcx
cmpq %rsi, %rdx
jl 0x2cda90
cltq
movb $0x0, (%r14,%rax)
testq %rax, %rax
jle 0x2cdad1
cmpb $0x42, -0x1(%r14,%rax)
leaq -0x1(%rax), %rax
jl 0x2cdabb
movq %r14, 0x28(%r15)
jmp 0x2cdadf
movq %r12, %rdi
callq 0x2824bb
testq %r14, %r14
je 0x2cdb15
movq %r14, %rdi
callq 0x172f0
movq %rax, %r15
andl $0x3fffffff, %r15d      # imm = 0x3FFFFFFF
je 0x2cdb15
testl %ebp, %ebp
je 0x2cdb1e
movq %rbx, %rdi
movl $0x5a, %esi
movl %ebp, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl %eax, %esi
jmp 0x2cdb23
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rdx
movl %r15d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x285198
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x2cddc7
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq $0x0, 0x8(%rsp)
cmpl $0x0, 0x30(%rdi)
jne 0x2cde9f
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x1b0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %r14, %rdi
callq 0x28e62e
testq %rax, %rax
je 0x2cde8e
movq %rax, %r12
incb 0x1e(%rbx)
leaq 0x108(%rbx), %r15
leaq 0xe0(%rsp), %rdi
movl $0xa0, %edx
movq %r15, %rsi
callq 0x17660
movl $0xa0, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x173a0
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2874c0
movq (%r13), %rsi
testq %rsi, %rsi
je 0x2cde69
movq %r14, %rdi
callq 0x28c3e7
movq %r14, %rdi
movq %r12, %rsi
callq 0x28c3e7
leaq 0xe0(%rsp), %rsi
movl $0xa0, %edx
movq %r15, %rdi
callq 0x17660
decb 0x1e(%rbx)
jmp 0x2cde9f
cmpb $0x0, 0x61(%r14)
jne 0x2cde9c
movl $0x12, 0x18(%rbx)
incl 0x30(%rbx)
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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:
movq (%rdi), %rax
movq 0x10(%rdi), %rdi
movq 0x20(%rax), %rax
movslq %esi, %rdx
movq %rdx, %rcx
shlq $0x5, %rcx
movq 0x18(%rax,%rcx), %rax
movl (%rax), %r8d
incl %r8d
movl $0x5e, %esi
movl $0x1, %ecx
jmp 0x2b200c
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
jle 0x2cdfdf
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rdx), %r8
movslq %ecx, %rax
movzwl (%r8,%rax,2), %ecx
movq 0x8(%rdi), %r8
movl %esi, %esi
xorl %r9d, %r9d
leaq 0x10cad1(%rip), %r10    # 0x3daa60
cmpw %cx, (%r8,%r9,2)
jne 0x2cdfd3
movq 0x40(%rdi), %r11
movq (%r11,%r9,8), %r11
movq 0x40(%rdx), %rbx
movq (%rbx,%rax,8), %rbx
xorl %r14d, %r14d
movzbl (%r11,%r14), %r15d
movzbl (%rbx,%r14), %r12d
cmpb %r12b, %r15b
jne 0x2cdfbf
testq %r15, %r15
jne 0x2cdfc9
jmp 0x2cdfce
movb (%r15,%r10), %bpl
cmpb (%r12,%r10), %bpl
jne 0x2cdfce
incq %r14
jmp 0x2cdfa9
cmpb %r12b, %r15b
je 0x2cdfe2
incq %r9
cmpq %rsi, %r9
jne 0x2cdf8f
xorl %eax, %eax
jmp 0x2cdfe7
xorl %eax, %eax
retq
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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:
movzwl 0x60(%rdi), %eax
testq %rax, %rax
je 0x2ce0de
movq 0x8(%rdi), %rdx
movq 0x18(%rdi), %rsi
incq %rax
xorl %ecx, %ecx
movswq -0x4(%rdx,%rax,2), %r8
testq %r8, %r8
js 0x2ce0d0
cmpw $0x3e, %r8w
jg 0x2ce0d0
movq 0x8(%rsi), %r9
movq %r8, %r10
shlq $0x5, %r10
movzwl 0x1c(%r9,%r10), %r9d
andl $0x20, %r9d
jne 0x2ce0d0
btsq %r8, %rcx
decq %rax
cmpq $0x1, %rax
jg 0x2ce0a3
notq %rcx
jmp 0x2ce0e5
movq $-0x1, %rcx
movq %rcx, 0x68(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x2ce16b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x28(%rdi), %ebp
movl %ebp, %eax
andl $0xffff6fef, %eax       # imm = 0xFFFF6FEF
movl %eax, 0x28(%rdi)
movq (%rdi), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x1e7(%rip), %rax       # 0x2ce302
movq %rax, 0x10(%rsp)
leaq 0x18ba(%rip), %rax      # 0x2cf9e1
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, 0x30(%rsp)
movl 0x124(%rdi), %eax
addl 0x28(%rsi), %eax
movl %eax, 0x124(%rdi)
movq (%rdi), %rcx
movl 0x88(%rcx), %edx
cmpl %eax, %edx
jge 0x2ce16e
leaq 0x1136a2(%rip), %rsi    # 0x3e17ff
xorl %eax, %eax
callq 0x284eb8
movl $0x1, %eax
jmp 0x2ce1b6
xorl %eax, %eax
retq
andl $0x9010, %ebp           # imm = 0x9010
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ca211
movl 0x28(%r14), %eax
movq (%r15), %rcx
subl %eax, 0x124(%rcx)
movl 0x28(%rbx), %eax
orl %eax, %ebp
andl $0x8010, %eax           # imm = 0x8010
orl %eax, 0x4(%r14)
movl %ebp, 0x28(%rbx)
movl $0x1, %eax
cmpl $0x0, 0x24(%rbx)
jg 0x2ce1b6
xorl %eax, %eax
cmpl $0x0, 0x30(%rcx)
setg %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %rbx
movq %rcx, %rbx
movl 0x28(%rsi), %eax
testb $0x20, %al
jne 0x2cfe78
testb $0x4, %al
jne 0x2cfe81
testb $0x8, %al
leaq 0x111399(%rip), %rax    # 0x3e1204
leaq 0x1113d2(%rip), %rcx    # 0x3e1244
cmoveq %rax, %rcx
jmp 0x2cfe88
leaq 0x1113a1(%rip), %rcx    # 0x3e1220
jmp 0x2cfe88
leaq 0x1113aa(%rip), %rcx    # 0x3e1232
leaq 0x1113c7(%rip), %rsi    # 0x3e1256
xorl %eax, %eax
callq 0x284eb8
testq %rbx, %rbx
je 0x2cfe9e
movb $0x77, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x8(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $-0x6a, (%rdi)
jne 0x2cff10
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2cfede
movq %r14, %rdi
callq 0x172f0
movq %rax, %rdx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
jmp 0x2cfee0
xorl %edx, %edx
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x29bf75
movsd (%r15), %xmm0
ucomisd 0x7f326(%rip), %xmm0    # 0x34f228
ja 0x2cff10
mulsd 0x10efcc(%rip), %xmm0   # 0x3deed8
cvttsd2si %xmm0, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb 0x11(%rdi), %al
andb $0x3, %al
cmpb $0x2, %al
jne 0x2d014f
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1(%rdi), %r15
xorl %r13d, %r13d
movzbl -0x1(%r15), %eax
testl %eax, %eax
je 0x2d0152
cmpl $0x2e, %eax
je 0x2d0152
incq %r13
incq %r15
jmp 0x2d0139
xorl %eax, %eax
retq
testq %r12, %r12
je 0x2d0175
movq %r12, %rsi
movl %r13d, %edx
callq 0x27e951
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x2d01f2
cmpb $0x0, (%r12,%r13)
jne 0x2d01f2
leaq 0x1(%r15), %r13
xorl %r12d, %r12d
movzbl -0x1(%r13), %eax
testl %eax, %eax
je 0x2d0192
cmpl $0x2e, %eax
je 0x2d0192
incq %r12
incq %r13
jmp 0x2d017c
testq %r14, %r14
je 0x2d01b4
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x27e951
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x2d01f2
cmpb $0x0, (%r14,%r12)
jne 0x2d01f2
testq %rbx, %rbx
je 0x2d01e9
leaq 0x10a8a0(%rip), %rax    # 0x3daa60
movzbl (%r13), %ecx
movzbl (%rbx), %edx
cmpb %dl, %cl
jne 0x2d01d3
testq %rcx, %rcx
jne 0x2d01dd
jmp 0x2d01e5
movb (%rcx,%rax), %sil
cmpb (%rdx,%rax), %sil
jne 0x2d01e5
incq %rbx
incq %r13
jmp 0x2d01c0
cmpb %dl, %cl
jne 0x2d01f0
movl $0x1, %eax
jmp 0x2d01f2
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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:
movswq 0x30(%rdi), %rax
movq 0x40(%rdi), %rcx
testb $0x60, 0x40(%rcx)
je 0x2d0344
movq 0x8(%rcx), %rdx
movq %rax, %rsi
shlq $0x5, %rsi
testb $0x60, 0x1c(%rdx,%rsi)
je 0x2d0344
movzwl 0x46(%rcx), %ecx
movq $-0x1, %rdx
movq $-0x1, %rax
shlq %cl, %rax
cmpw $0x40, %cx
notq %rax
cmovgeq %rdx, %rax
retq
cmpw $0x3f, %ax
movl $0x3f, %ecx
cmovll %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAddCollateString
SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
  Token s;
  assert( zC!=0 );
  sqlite3TokenInit(&s, (char*)zC);
  return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0x2d037f
movq %rdx, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x2d0381
xorl %eax, %eax
leaq 0x8(%rsp), %rdx
movl %eax, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x2c0174
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
xorl %ebp, %ebp
cmpb $0x0, 0xb5(%r15)
jne 0x2d0481
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x20(%r15), %rax
movslq %ecx, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %r8
movq 0x1d0(%r15), %rdi
movq 0x160(%rbx), %r9
movl $0x14, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %r8, (%rsp)
callq *0x1c8(%r15)
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x2d0460
leaq 0x8d706(%rip), %rdi     # 0x35db1d
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x27e482
testl %r14d, %r14d
jne 0x2d0430
cmpl $0x3, 0x28(%r15)
jl 0x2d0445
leaq 0x110edb(%rip), %rdi    # 0x3e1312
movq (%rsp), %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x27e482
leaq 0x110ecc(%rip), %rsi    # 0x3e1318
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x284eb8
movl $0x17, %eax
jmp 0x2d047e
testl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
je 0x2d0481
leaq 0x1109fa(%rip), %rsi    # 0x3e0e69
movq %rbx, %rdi
xorl %eax, %eax
callq 0x284eb8
movl $0x1, %eax
movl %eax, 0x18(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2d04da
leaq 0x10a5be(%rip), %rax    # 0x3daa60
movq (%rbx), %rcx
xorl %esi, %esi
movzbl (%rcx,%rsi), %r8d
movzbl (%rdx,%rsi), %r9d
cmpb %r9b, %r8b
jne 0x2d04bd
testq %r8, %r8
jne 0x2d04c7
jmp 0x2d04cc
movb (%r8,%rax), %r10b
cmpb (%r9,%rax), %r10b
jne 0x2d04cc
incq %rsi
jmp 0x2d04a7
cmpb %r9b, %r8b
je 0x2d04e8
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x2d04a2
leaq 0x110ed8(%rip), %rsi    # 0x3e13b9
xorl %eax, %eax
callq 0x284eb8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movzbl (%rsi), %eax
orl $0x2, %eax
cmpl $0xa6, %eax
jne 0x2d053c
movq 0x28(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x2d050a
movl (%rcx), %edi
jmp 0x2d050c
xorl %edi, %edi
testl %edi, %edi
jle 0x2d052c
movl 0x2c(%rsi), %edx
movl %edi, %edi
imulq $0x70, %rdi, %rdi
xorl %r8d, %r8d
cmpl 0x48(%rcx,%r8), %edx
je 0x2d0539
addq $0x70, %r8
cmpq %r8, %rdi
jne 0x2d051c
movl 0x2c(%rsi), %ecx
cmpl 0x8(%rax), %ecx
jge 0x2d053c
incl 0x10(%rax)
jmp 0x2d053c
incl 0xc(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x28(%rdi), %rax
cmpl $0x7fffffff, 0x8(%rax)  # imm = 0x7FFFFFFF
jne 0x2d0560
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x2d0560
cmpl $0x0, (%rcx)
je 0x2d0560
movl 0x48(%rcx), %ecx
movl %ecx, 0x8(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SelectPrep
SQLITE_PRIVATE void sqlite3SelectPrep(
  Parse *pParse,         /* The parser context */
  Select *p,             /* The SELECT statement being coded. */
  NameContext *pOuterNC  /* Name context for container */
){
  assert( p!=0 || pParse->db->mallocFailed );
  if( pParse->db->mallocFailed ) return;
  if( p->selFlags & SF_HasTypeInfo ) return;
  sqlite3SelectExpand(pParse, p);
  if( pParse->nErr || pParse->db->mallocFailed ) return;
  sqlite3ResolveSelectNames(pParse, p, pOuterNC);
  if( pParse->nErr || pParse->db->mallocFailed ) return;
  sqlite3SelectAddTypeInfo(pParse, p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2d066a
movq %rsi, %rbx
testb $-0x80, 0x4(%rsi)
jne 0x2d066a
movq %rdx, %r15
movq %rdi, %r14
leaq 0x740(%rip), %r12       # 0x2d0cd5
movq %r12, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpb $0x0, 0x22(%rdi)
je 0x2d05c5
leaq 0x72c(%rip), %rax       # 0x2d0cd8
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq %rbx, %rsi
callq 0x2ca2ea
leaq 0x877(%rip), %rax       # 0x2d0e43
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
leaq 0x1678(%rip), %rax      # 0x2d1c54
movq %rax, 0x18(%rdi)
movw $0x0, 0x24(%rdi)
movq %rbx, %rsi
callq 0x2ca2ea
cmpl $0x0, 0x30(%r14)
jne 0x2d066a
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2d066a
leaq -0x2303(%rip), %rax     # 0x2ce302
leaq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq -0xc34(%rip), %rax      # 0x2cf9e1
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq %r14, (%rdi)
movq %r15, 0x28(%rdi)
movq %rbx, %rsi
callq 0x2ca2ea
cmpl $0x0, 0x30(%r14)
jne 0x2d066a
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2d066a
leaq 0x271d(%rip), %rax      # 0x2d2d64
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
leaq 0x2710(%rip), %rax      # 0x2d2d67
movq %rax, 0x18(%rdi)
movq %r12, 0x8(%rdi)
movq %r14, (%rdi)
movq %rbx, %rsi
callq 0x2ca2ea
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SelectWrongNumTermsError
SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){
  if( p->selFlags & SF_Values ){
    sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
  }else{
    sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
      " do not have the same number of result columns", selectOpName(p->op));
  }
}

// Assembly:
testb $0x2, 0x5(%rsi)
jne 0x2d08ae
movb (%rsi), %al
addb $0x7b, %al
cmpb $0x2, %al
ja 0x2d08bc
movzbl %al, %eax
leaq 0x1f2a70(%rip), %rcx    # 0x4c3318
movq (%rcx,%rax,8), %rdx
jmp 0x2d08c3
leaq 0x110e4a(%rip), %rsi    # 0x3e16ff
xorl %eax, %eax
jmp 0x284eb8
leaq 0x110ed7(%rip), %rdx    # 0x3e179a
leaq 0x110e63(%rip), %rsi    # 0x3e172d
xorl %eax, %eax
jmp 0x284eb8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: selectPopWith
static void selectPopWith(Walker *pWalker, Select *p){
  Parse *pParse = pWalker->pParse;
  if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
    With *pWith = findRightmost(p)->pWith;
    if( pWith!=0 ){
      assert( pParse->pWith==pWith || pParse->nErr );
      pParse->pWith = pWith->pOuter;
    }
  }
}

// Assembly:
movq (%rdi), %rax
cmpq $0x0, 0x190(%rax)
je 0x2d1c68
cmpq $0x0, 0x50(%rsi)
je 0x2d1c69
retq
movq %rsi, %rcx
movq 0x58(%rsi), %rsi
testq %rsi, %rsi
jne 0x2d1c69
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
je 0x2d1c68
movq 0x8(%rcx), %rcx
movq %rcx, 0x190(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3LocateTableItem
SQLITE_PRIVATE Table *sqlite3LocateTableItem(
  Parse *pParse,
  u32 flags,
  struct SrcList_item *p
){
  const char *zDb;
  assert( p->pSchema==0 || p->zDatabase==0 );
  if( p->pSchema ){
    int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
    zDb = pParse->db->aDb[iDb].zDbSName;
  }else{
    zDb = p->zDatabase;
  }
  return sqlite3LocateTable(pParse, flags, p->zName, zDb);
}

// Assembly:
movq (%rdx), %rcx
testq %rcx, %rcx
je 0x2d1d25
movq (%rdi), %r8
movq 0x20(%r8), %r9
addq $0x18, %r9
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r10      # imm = 0x100000000
addq %r10, %rax
leaq 0x20(%r9), %r11
cmpq %rcx, (%r9)
movq %r11, %r9
jne 0x2d1d0c
sarq $0x1b, %rax
addq 0x20(%r8), %rax
jmp 0x2d1d29
leaq 0x8(%rdx), %rax
movq (%rax), %rcx
movq 0x10(%rdx), %rdx
jmp 0x284c10
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IndexedByLookup
SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
  if( pFrom->pTab && pFrom->fg.isIndexedBy ){
    Table *pTab = pFrom->pTab;
    char *zIndexedBy = pFrom->u1.zIndexedBy;
    Index *pIdx;
    for(pIdx=pTab->pIndex;
        pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
        pIdx=pIdx->pNext
    );
    if( !pIdx ){
      sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
      pParse->checkSchema = 1;
      return SQLITE_ERROR;
    }
    pFrom->pIBIndex = pIdx;
  }
  return SQLITE_OK;
}

// Assembly:
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x2d20a0
testb $0x2, 0x3d(%rsi)
je 0x2d20a0
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rsi), %rdx
movq 0x10(%rax), %rax
testq %rax, %rax
sete %bpl
je 0x2d2071
leaq 0x108a2c(%rip), %rcx    # 0x3daa60
movq (%rax), %rdi
xorl %r8d, %r8d
movzbl (%rdi,%r8), %r9d
movzbl (%rdx,%r8), %r10d
cmpb %r10b, %r9b
jne 0x2d2050
testq %r9, %r9
jne 0x2d205a
jmp 0x2d205f
movb (%r9,%rcx), %r11b
cmpb (%r10,%rcx), %r11b
jne 0x2d205f
incq %r8
jmp 0x2d203a
cmpb %r10b, %r9b
je 0x2d208a
movq 0x28(%rax), %rax
testq %rax, %rax
sete %bpl
jne 0x2d2034
leaq 0x10f575(%rip), %rsi    # 0x3e15ed
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x284eb8
movb $0x1, 0x1d(%rbx)
jmp 0x2d208e
movq %rax, 0x68(%rsi)
movl $0x1, %eax
testb $0x1, %bpl
leaq 0x8(%rsp), %rsp
popq %rbx
popq %rbp
jne 0x2d20a2
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: tableAndColumnIndex
static int tableAndColumnIndex(
  SrcList *pSrc,       /* Array of tables to search */
  int N,               /* Number of tables in pSrc->a[] to search */
  const char *zCol,    /* Name of the column we are looking for */
  int *piTab,          /* Write index of pSrc->a[] here */
  int *piCol,          /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
  int bIgnoreHidden    /* True to ignore hidden columns */
){
  int i;               /* For looping over tables in pSrc */
  int iCol;            /* Index of column matching zCol */

  assert( (piTab==0)==(piCol==0) );  /* Both or neither are NULL */
  for(i=0; i<N; i++){
    iCol = columnIndex(pSrc->a[i].pTab, zCol);
    if( iCol>=0
     && (bIgnoreHidden==0 || IsHiddenColumn(&pSrc->a[i].pTab->aCol[iCol])==0)
    ){
      if( piTab ){
        *piTab = i;
        *piCol = iCol;
      }
      return 1;
    }
  }
  return 0;
}

// Assembly:
testl %esi, %esi
jle 0x2d241e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %rdx, %r15
movq %rdi, %r12
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl %esi, %r14d
addq $0x28, %r12
xorl %ebx, %ebx
movq (%r12), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2d2bfc
testl %eax, %eax
js 0x2d240e
testl %ebp, %ebp
je 0x2d2422
movq 0x8(%r13), %rcx
movl %eax, %edx
shlq $0x5, %rdx
testb $0x2, 0x1c(%rcx,%rdx)
je 0x2d2422
incq %rbx
addq $0x70, %r12
cmpq %rbx, %r14
jne 0x2d23e6
xorl %ecx, %ecx
jmp 0x2d243a
xorl %ecx, %ecx
jmp 0x2d2448
movl $0x1, %ecx
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x2d243a
movl %ebx, (%rdx)
movq 0x8(%rsp), %rdx
movl %eax, (%rdx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SetJoinExpr
SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr *p, int iTable){
  while( p ){
    ExprSetProperty(p, EP_FromJoin);
    assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
    ExprSetVVAProperty(p, EP_NoReduce);
    p->iRightJoinTable = (i16)iTable;
    if( p->op==TK_FUNCTION && p->x.pList ){
      int i;
      for(i=0; i<p->x.pList->nExpr; i++){
        sqlite3SetJoinExpr(p->x.pList->a[i].pExpr, iTable);
      }
    }
    sqlite3SetJoinExpr(p->pLeft, iTable);
    p = p->pRight;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2d2bfb
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
orb $0x1, 0x4(%r14)
movw %bx, 0x34(%r14)
cmpb $-0x57, (%r14)
jne 0x2d2bdc
cmpq $0x0, 0x20(%r14)
je 0x2d2bdc
movq 0x20(%r14), %rax
cmpl $0x0, (%rax)
jle 0x2d2bdc
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%rax,%r15), %rdi
movl %ebx, %esi
callq 0x2d2b83
incq %r12
movq 0x20(%r14), %rax
movslq (%rax), %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0x2d2bbe
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x2d2b83
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x2d2b95
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: columnIndex
static int columnIndex(Table *pTab, const char *zCol){
  int i;
  u8 h = sqlite3StrIHash(zCol);
  Column *pCol;
  for(pCol=pTab->aCol, i=0; i<pTab->nCol; pCol++, i++){
    if( pCol->hName==h && sqlite3StrICmp(pCol->zName, zCol)==0 ) return i;
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2d2c2a
movb (%rsi), %dl
testb %dl, %dl
je 0x2d2c2a
leaq 0x1(%rsi), %rax
xorl %ecx, %ecx
leaq 0x107e48(%rip), %r8     # 0x3daa60
movzbl %dl, %edx
addb (%rdx,%r8), %cl
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x2d2c18
jmp 0x2d2c2c
xorl %ecx, %ecx
movswl 0x46(%rdi), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x2d2c8a
movq 0x8(%rdi), %r8
xorl %edi, %edi
leaq 0x107e1a(%rip), %r9     # 0x3daa60
cmpb %cl, 0x1b(%r8)
jne 0x2d2c7c
movq (%r8), %r10
xorl %r11d, %r11d
movzbl (%r10,%r11), %ebx
movzbl (%rsi,%r11), %r14d
cmpb %r14b, %bl
jne 0x2d2c68
testq %rbx, %rbx
jne 0x2d2c72
jmp 0x2d2c77
movb (%rbx,%r9), %bpl
cmpb (%r14,%r9), %bpl
jne 0x2d2c77
incq %r11
jmp 0x2d2c52
cmpb %r14b, %bl
je 0x2d2c88
addq $0x20, %r8
incl %edi
cmpl %edx, %edi
jne 0x2d2c46
jmp 0x2d2c8a
movl %edi, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3CreateColumnExpr
SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
  Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
  if( p ){
    struct SrcList_item *pItem = &pSrc->a[iSrc];
    Table *pTab = p->y.pTab = pItem->pTab;
    p->iTable = pItem->iCursor;
    if( p->y.pTab->iPKey==iCol ){
      p->iColumn = -1;
    }else{
      p->iColumn = (ynVar)iCol;
      if( (pTab->tabFlags & TF_HasGenerated)!=0
       && (pTab->aCol[iCol].colFlags & COLFLAG_GENERATED)!=0
      ){
        testcase( pTab->nCol==63 );
        testcase( pTab->nCol==64 );
        pItem->colUsed = pTab->nCol>=64 ? ALLBITS : MASKBIT(pTab->nCol)-1;
      }else{
        testcase( iCol==BMS );
        testcase( iCol==BMS-1 );
        pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
      }
    }
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movl $0x48, %esi
callq 0x28c518
testq %rax, %rax
je 0x2d2d5f
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x40(%rax)
movb $-0x5c, (%rax)
movw $0xffff, 0x32(%rax)     # imm = 0xFFFF
movl $0x1, 0x28(%rax)
movslq %ebp, %rcx
imulq $0x70, %rcx, %rdx
movq 0x28(%r14,%rdx), %rcx
movq %rcx, 0x40(%rax)
movl 0x48(%r14,%rdx), %esi
movl %esi, 0x2c(%rax)
movswl 0x44(%rcx), %esi
cmpl %ebx, %esi
jne 0x2d2cff
movw $0xffff, 0x30(%rax)     # imm = 0xFFFF
jmp 0x2d2d5f
addq %r14, %rdx
addq $0x8, %rdx
movw %bx, 0x30(%rax)
testb $0x60, 0x40(%rcx)
je 0x2d2d48
movq 0x8(%rcx), %rsi
movslq %ebx, %rdi
shlq $0x5, %rdi
testb $0x60, 0x1c(%rsi,%rdi)
je 0x2d2d48
movzwl 0x46(%rcx), %ecx
movq $-0x1, %rsi
movq $-0x1, %rdi
shlq %cl, %rdi
cmpw $0x40, %cx
notq %rdi
cmovgeq %rsi, %rdi
movq %rdi, 0x58(%rdx)
jmp 0x2d2d5f
cmpl $0x3f, %ebx
movl $0x3f, %ecx
cmovll %ebx, %ecx
movl $0x1, %esi
shlq %cl, %rsi
orq %rsi, 0x58(%rdx)
popq %rbx
popq %r14
popq %rbp
retq