LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprCodeFactorable
SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
  if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
    sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
  }else{
    sqlite3ExprCodeCopy(pParse, pExpr, target);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0x23(%rdi)
je 0x2c3406
movw $0x2, 0x2c(%rsp)
leaq -0x2a39(%rip), %rax     # 0x2c0987
movq %rax, 0x10(%rsp)
leaq -0x294c(%rip), %rax     # 0x2c0a80
movq %rax, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
testq %r14, %r14
je 0x2c33f7
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2c0a8c
cmpw $0x0, 0x24(%r12)
je 0x2c3406
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2be7a4
jmp 0x2c3413
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2c00af
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprSimplifiedAndOr
SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
  assert( pExpr!=0 );
  if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
    Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
    Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
    if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){
      pExpr = pExpr->op==TK_AND ? pRight : pLeft;
    }else if( ExprAlwaysTrue(pRight) || ExprAlwaysFalse(pLeft) ){
      pExpr = pExpr->op==TK_AND ? pLeft : pRight;
    }
  }
  return pExpr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %r15b
leal -0x2b(%r15), %eax
cmpb $0x1, %al
ja 0x2c3479
movq 0x18(%rbx), %rdi
callq 0x2c341f
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x2c341f
movl 0x4(%rax), %ecx
movl %ecx, %edx
andl $0x10000001, %edx       # imm = 0x10000001
cmpl $0x10000000, %edx       # imm = 0x10000000
je 0x2c346e
movl 0x4(%r14), %edx
movl %edx, %esi
andl $0x20000001, %esi       # imm = 0x20000001
cmpl $0x20000000, %esi       # imm = 0x20000000
jne 0x2c3482
cmpb $0x2c, %r15b
cmoveq %r14, %rax
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
andl $0x20000001, %ecx       # imm = 0x20000001
cmpl $0x20000000, %ecx       # imm = 0x20000000
je 0x2c349e
andl $0x10000001, %edx       # imm = 0x10000001
cmpl $0x10000000, %edx       # imm = 0x10000000
jne 0x2c3479
cmpb $0x2c, %r15b
cmoveq %rax, %r14
movq %r14, %rbx
jmp 0x2c3479
// File: /workspace/github_c_makefile_star2_O3/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 0x2c3867
cmpb $0x0, 0xb5(%rdi)
je 0x2c3873
leaq 0x113f58(%rip), %rsi    # 0x3d77ae
movq %rbx, %rdi
xorl %eax, %eax
callq 0x27b48d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2c3882
movzbl 0xb4(%rdi), %eax
movq %r14, (%rcx)
jmp 0x2c3882
movq %rdx, (%rcx)
movq %r14, %rsi
callq 0x2c3afd
testl %eax, %eax
js 0x2c388a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x113f2e(%rip), %rsi    # 0x3d77bf
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x27b48d
jmp 0x2c3860
// File: /workspace/github_c_makefile_star2_O3/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 0x2c26e5
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_O3/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 0x2bc630
movq %rax, %r14
leaq 0x112a96(%rip), %r8     # 0x3d6533
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x2bc937
movq %r14, %rdi
movl $0x61, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x2a83e1
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
jne 0x2c3aeb
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 0x2c3af8
movl $0x1, 0x34(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c3b7f
movq %rax, %r15
movb $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2811f8
movb $0x5f, (%r15)
testq %rax, %rax
je 0x2c3b7f
cmpl $0x0, 0x54(%rax)
je 0x2c3b7f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2c3b87
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c3c27
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
testq %r12, %r12
je 0x2c3bbf
movq %r12, %rdi
callq 0x172f0
movq %rax, %r13
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
jmp 0x2c3bc2
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x275033
testl %eax, %eax
jne 0x2c3c27
movl %r13d, %r12d
cmpb $0x5f, (%rbx,%r12)
jne 0x2c3c27
addq $0x1f0, %r14            # imm = 0x1F0
movq 0x58(%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2a547e
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2c3c27
movq (%rax), %rax
cmpl $0x3, (%rax)
jl 0x2c3c27
movq 0xb8(%rax), %rax
testq %rax, %rax
je 0x2c3c27
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_O3/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 $0xb0, %rsp
movq %r8, %rbx
xorl %eax, %eax
movq %rax, 0xa8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rsp)
movups %xmm0, 0x88(%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 0x2c4195
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 0x78(%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 0x2c496c
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x2c41d9
testq %rbx, %rbx
je 0x2c41d7
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x2c4a43
jmp 0x2c41d9
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c6ee7
movq %r12, 0x30(%rbx)
cmpl $0x0, 0x30(%r14)
jne 0x2c42ec
movq %r13, %r12
movq 0x50(%r13), %r13
testq %r13, %r13
jne 0x2c4272
movl $0x80, %esi
movq %rbx, %rdi
callq 0x279b27
testq %rax, %rax
je 0x2c42e9
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 0x2c8c0a
movsbl %bpl, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2c8fcf
movw $0xffff, 0x44(%r15)     # imm = 0xFFFF
cmpb $0x0, 0x61(%rbx)
je 0x2c42ec
movq %rbx, %rdi
movq %r15, %rsi
callq 0x272447
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_O3/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 0x2c438e
movq %rsi, %r15
movq (%rbx), %r12
movswq 0x46(%rsi), %rdi
incq %rdi
callq 0x272ae6
testq %rax, %rax
je 0x2c43e6
movq %rax, %r14
movzwl 0x46(%r15), %edx
xorl %eax, %eax
testw %dx, %dx
jle 0x2c4374
movl $0x1c, %ecx
xorl %esi, %esi
movq 0x8(%r15), %rdi
testb $0x20, (%rdi,%rcx)
jne 0x2c4362
movb -0x3(%rdi,%rcx), %dl
movslq %eax, %rdi
incl %eax
movb %dl, (%r14,%rdi)
movzwl 0x46(%r15), %edx
incq %rsi
movswq %dx, %rdi
addq $0x20, %rcx
cmpq %rdi, %rsi
jl 0x2c4346
cltq
movb $0x0, (%r14,%rax)
testq %rax, %rax
jle 0x2c438a
cmpb $0x42, -0x1(%r14,%rax)
leaq -0x1(%rax), %rax
jl 0x2c4374
movq %r14, 0x28(%r15)
movq %r14, %rdi
callq 0x172f0
movq %rax, %r15
andl $0x3fffffff, %r15d      # imm = 0x3FFFFFFF
je 0x2c43c2
testl %ebp, %ebp
je 0x2c43cb
movq %rbx, %rdi
movl $0x5a, %esi
movl %ebp, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %rbx, %rdi
movl %eax, %esi
jmp 0x2c43d3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
movl %r15d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27b778
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x278b1c
// File: /workspace/github_c_makefile_star2_O3/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 0x2c467d
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 0x2c4755
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 0x284ab7
testq %rax, %rax
je 0x2c4744
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 0x27daa4
movq (%r13), %rsi
testq %rsi, %rsi
je 0x2c471f
movq %r14, %rdi
callq 0x282904
movq %r14, %rdi
movq %r12, %rsi
callq 0x282904
leaq 0xe0(%rsp), %rsi
movl $0xa0, %edx
movq %r15, %rdi
callq 0x17660
decb 0x1e(%rbx)
jmp 0x2c4755
cmpb $0x0, 0x61(%r14)
jne 0x2c4752
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_O3/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 0x2c486f
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 0x10caca(%rip), %r10    # 0x3d12e0
cmpw %cx, (%r8,%r9,2)
jne 0x2c4855
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 0x2c4846
testq %r15, %r15
jne 0x2c4850
jmp 0x2c4861
movb (%r15,%r10), %bpl
cmpb (%r12,%r10), %bpl
jne 0x2c4855
incq %r14
jmp 0x2c4830
incq %r9
cmpq %rsi, %r9
jne 0x2c4816
xorl %eax, %eax
jmp 0x2c4866
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c4960
movq 0x8(%rdi), %rdx
movq 0x18(%rdi), %rsi
incq %rax
xorl %ecx, %ecx
movswq -0x4(%rdx,%rax,2), %r8
testq %r8, %r8
js 0x2c4952
cmpw $0x3e, %r8w
ja 0x2c4952
movq 0x8(%rsi), %r9
movq %r8, %r10
shlq $0x5, %r10
movzwl 0x1c(%r9,%r10), %r9d
andl $0x20, %r9d
jne 0x2c4952
btsq %r8, %rcx
decq %rax
cmpq $0x1, %rax
ja 0x2c4925
notq %rcx
jmp 0x2c4967
movq $-0x1, %rcx
movq %rcx, 0x68(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c49ed
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 0x1d2(%rip), %rax       # 0x2c4b6f
movq %rax, 0x10(%rsp)
leaq 0x1943(%rip), %rax      # 0x2c62ec
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 0x2c49f0
leaq 0x1136cb(%rip), %rsi    # 0x3d80aa
xorl %eax, %eax
callq 0x27b48d
movl $0x1, %eax
jmp 0x2c4a38
xorl %eax, %eax
retq
andl $0x9010, %ebp           # imm = 0x9010
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c0a8c
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 0x2c4a38
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_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResolveExprListNames
SQLITE_PRIVATE int sqlite3ResolveExprListNames(
  NameContext *pNC,       /* Namespace to resolve expressions in. */
  ExprList *pList         /* The expression list to be analyzed. */
){
  int i;
  int savedHasAgg = 0;
  Walker w;
  if( pList==0 ) return WRC_Continue;
  w.pParse = pNC->pParse;
  w.xExprCallback = resolveExprStep;
  w.xSelectCallback = resolveSelectStep;
  w.xSelectCallback2 = 0;
  w.u.pNC = pNC;
  savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
  for(i=0; i<pList->nExpr; i++){
    Expr *pExpr = pList->a[i].pExpr;
    if( pExpr==0 ) continue;
#if SQLITE_MAX_EXPR_DEPTH>0
    w.pParse->nHeight += pExpr->nHeight;
    if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
      return WRC_Abort;
    }
#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 );
    if( pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin) ){
      ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
      savedHasAgg |= pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
      pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg|NC_HasWin);
    }
    if( pNC->nErr>0 || w.pParse->nErr>0 ) return WRC_Abort;
  }
  pNC->ncFlags |= savedHasAgg;
  return WRC_Continue;
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x2c4b59
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xfe(%rip), %rax        # 0x2c4b6f
movq %rax, 0x10(%rsp)
leaq 0x186f(%rip), %rax      # 0x2c62ec
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, 0x30(%rsp)
movl 0x28(%rbx), %ecx
movl %ecx, %ebp
andl $0x9010, %ebp           # imm = 0x9010
andl $0xffff6fef, %ecx       # imm = 0xFFFF6FEF
movl %ecx, 0x28(%rbx)
movl (%rsi), %eax
testl %eax, %eax
jle 0x2c4b44
leaq 0x8(%r14), %r13
xorl %r15d, %r15d
movq (%r13), %r12
testq %r12, %r12
je 0x2c4b31
movl 0x124(%rdi), %eax
addl 0x28(%r12), %eax
movl %eax, 0x124(%rdi)
movq (%rdi), %rcx
movl 0x88(%rcx), %edx
cmpl %eax, %edx
jl 0x2c4b5a
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2c0a8c
movl 0x28(%r12), %eax
movq 0x8(%rsp), %rdi
subl %eax, 0x124(%rdi)
movl 0x28(%rbx), %ecx
movl %ecx, %eax
andl $0x9010, %eax           # imm = 0x9010
je 0x2c4b1d
movl %ecx, %edx
andl $0x8010, %edx           # imm = 0x8010
orl %edx, 0x4(%r12)
orl %eax, %ebp
andl $0xffff6fef, %ecx       # imm = 0xFFFF6FEF
movl %ecx, 0x28(%rbx)
movl $0x2, %eax
cmpl $0x0, 0x24(%rbx)
jg 0x2c4b4b
cmpl $0x0, 0x30(%rdi)
jg 0x2c4b4b
movl (%r14), %eax
incq %r15
movslq %eax, %rdx
addq $0x18, %r13
cmpq %rdx, %r15
jl 0x2c4ab5
orl %ebp, %ecx
movl %ecx, 0x28(%rbx)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x113549(%rip), %rsi    # 0x3d80aa
xorl %eax, %eax
callq 0x27b48d
movl $0x2, %eax
jmp 0x2c4b4b
// File: /workspace/github_c_makefile_star2_O3/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
testb $0x20, %sil
jne 0x2c679b
testb $0x4, %sil
jne 0x2c67a4
testb $0x8, %sil
leaq 0x111321(%rip), %rax    # 0x3d7aaf
leaq 0x11135a(%rip), %rcx    # 0x3d7aef
cmoveq %rax, %rcx
jmp 0x2c67ab
leaq 0x111329(%rip), %rcx    # 0x3d7acb
jmp 0x2c67ab
leaq 0x111332(%rip), %rcx    # 0x3d7add
leaq 0x11134f(%rip), %rsi    # 0x3d7b01
xorl %eax, %eax
callq 0x27b48d
testq %rbx, %rbx
je 0x2c67c1
movb $0x77, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c6833
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2c6801
movq %r14, %rdi
callq 0x172f0
movq %rax, %rdx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
jmp 0x2c6803
xorl %edx, %edx
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0x292288
movsd (%r15), %xmm0
ucomisd 0x7fa03(%rip), %xmm0    # 0x346228
ja 0x2c6833
mulsd 0x10efb9(%rip), %xmm0   # 0x3d57e8
cvttsd2si %xmm0, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c6a61
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rdi
movl $0x1, %r8d
movzbl -0x1(%rdi), %r9d
testl %r9d, %r9d
je 0x2c6a64
cmpl $0x2e, %r9d
je 0x2c6a64
incq %r8
incq %rdi
jmp 0x2c6a49
xorl %eax, %eax
retq
testq %rcx, %rcx
je 0x2c6ac9
cmpq $0x1, %r8
je 0x2c6ac1
xorl %r10d, %r10d
leaq 0x10a867(%rip), %r9     # 0x3d12e0
movl %r8d, %r11d
movzbl (%rax,%r10), %ebx
testq %rbx, %rbx
je 0x2c6aa7
movzbl (%rbx,%r9), %ebx
movzbl (%rcx,%r10), %r14d
movb (%r14,%r9), %bpl
cmpb %bpl, %bl
jne 0x2c6ab2
decl %r11d
incq %r10
cmpl $0x1, %r11d
ja 0x2c6a7c
jmp 0x2c6ac1
movzbl (%rcx,%r10), %eax
movb (%rax,%r9), %bpl
xorl %ebx, %ebx
movzbl %bpl, %r9d
xorl %eax, %eax
cmpl %r9d, %ebx
jne 0x2c6b4a
cmpb $0x0, -0x1(%rcx,%r8)
jne 0x2c6b48
leaq 0x1(%rdi), %rcx
movl $0x1, %eax
movzbl -0x1(%rcx), %r8d
testl %r8d, %r8d
je 0x2c6aea
cmpl $0x2e, %r8d
je 0x2c6aea
incq %rcx
incq %rax
jmp 0x2c6ad2
testq %rdx, %rdx
je 0x2c6b4f
cmpq $0x1, %rax
je 0x2c6b41
leaq 0x10a7e4(%rip), %r8     # 0x3d12e0
movl %eax, %r10d
movq %rdx, %r9
movzbl (%rdi), %r11d
testq %r11, %r11
je 0x2c6b2e
movzbl (%r11,%r8), %r11d
movzbl (%r9), %ebx
movb (%rbx,%r8), %bl
cmpb %bl, %r11b
jne 0x2c6b39
incq %rdi
incq %r9
decl %r10d
cmpl $0x1, %r10d
ja 0x2c6b02
jmp 0x2c6b41
movzbl (%r9), %edi
movb (%rdi,%r8), %bl
xorl %r11d, %r11d
movzbl %bl, %edi
cmpl %edi, %r11d
jne 0x2c6b48
cmpb $0x0, -0x1(%rdx,%rax)
je 0x2c6b4f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %eax
testq %rsi, %rsi
je 0x2c6b4a
leaq 0x10a780(%rip), %rdx    # 0x3d12e0
movzbl (%rcx), %edi
movzbl (%rsi), %r8d
cmpb %r8b, %dil
jne 0x2c6b73
testq %rdi, %rdi
jne 0x2c6b7d
jmp 0x2c6b4a
movb (%rdi,%rdx), %dil
cmpb (%r8,%rdx), %dil
jne 0x2c6b48
incq %rsi
incq %rcx
jmp 0x2c6b60
// File: /workspace/github_c_makefile_star2_O3/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:
testb $0x60, 0x40(%rsi)
je 0x2c6cc9
movq 0x8(%rsi), %rax
movswq %di, %rcx
shlq $0x5, %rcx
testb $0x60, 0x1c(%rax,%rcx)
je 0x2c6cc9
movzwl 0x46(%rsi), %ecx
movq $-0x1, %rdx
movq $-0x1, %rax
shlq %cl, %rax
cmpw $0x40, %cx
notq %rax
cmovgeq %rdx, %rax
retq
cmpw $0x3f, %di
movl $0x3f, %ecx
cmovll %edi, %ecx
movl $0x1, %eax
shlq %cl, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c6d04
movq %rdx, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x2c6d06
xorl %eax, %eax
leaq 0x8(%rsp), %rdx
movl %eax, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x2b6994
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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), %r14
xorl %r15d, %r15d
cmpb $0x0, 0xb5(%r14)
jne 0x2c6e0b
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x20(%r14), %rax
movslq %ecx, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %r8
movq 0x1d0(%r14), %rdi
movq 0x160(%rbx), %r9
movl $0x14, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %r8, (%rsp)
callq *0x1c8(%r14)
cmpl $0x1, %eax
jne 0x2c6de8
leaq 0x8dd4b(%rip), %rdi     # 0x354ae5
movq %r13, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x274b53
testl %ebp, %ebp
jne 0x2c6db2
cmpl $0x3, 0x28(%r14)
jl 0x2c6dc7
leaq 0x110e04(%rip), %rdi    # 0x3d7bbd
movq (%rsp), %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x274b53
leaq 0x110df5(%rip), %rsi    # 0x3d7bc3
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x27b48d
movl $0x1, %r15d
movl $0x17, %eax
jmp 0x2c6e08
movl %eax, %r15d
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
je 0x2c6e0b
leaq 0x11091b(%rip), %rsi    # 0x3d7714
movq %rbx, %rdi
xorl %eax, %eax
callq 0x27b48d
movl $0x1, %eax
movl %eax, 0x18(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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
testq %rsi, %rsi
je 0x2c6e60
movq %rsi, %rbx
leaq 0x10a4b3(%rip), %rax    # 0x3d12e0
movq (%rbx), %rcx
xorl %esi, %esi
movzbl (%rcx,%rsi), %r8d
movzbl (%rdx,%rsi), %r9d
cmpb %r9b, %r8b
jne 0x2c6e48
testq %r8, %r8
jne 0x2c6e52
jmp 0x2c6e70
movb (%r8,%rax), %r8b
cmpb (%r9,%rax), %r8b
jne 0x2c6e57
incq %rsi
jmp 0x2c6e32
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x2c6e2d
leaq 0x110dfd(%rip), %rsi    # 0x3d7c64
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x27b48d
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c6ec0
movq 0x28(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x2c6eb0
movslq (%rcx), %rdi
testq %rdi, %rdi
jle 0x2c6eb0
movl 0x2c(%rsi), %edx
imulq $0x70, %rdi, %rsi
xorl %edi, %edi
cmpl 0x48(%rcx,%rdi), %edx
je 0x2c6ebd
addq $0x70, %rdi
cmpq %rdi, %rsi
jne 0x2c6e9f
jmp 0x2c6eb3
movl 0x2c(%rsi), %edx
cmpl 0x8(%rax), %edx
jge 0x2c6ec0
incl 0x10(%rax)
jmp 0x2c6ec0
incl 0xc(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c6ee4
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x2c6ee4
cmpl $0x0, (%rcx)
je 0x2c6ee4
movl 0x48(%rcx), %ecx
movl %ecx, 0x8(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c6fee
movq %rsi, %rbx
testb $-0x80, 0x4(%rsi)
jne 0x2c6fee
movq %rdx, %r15
movq %rdi, %r14
leaq 0x6b1(%rip), %r12       # 0x2c75ca
movq %r12, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpb $0x0, 0x22(%rdi)
je 0x2c6f49
leaq 0x69d(%rip), %rax       # 0x2c75cd
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq %rbx, %rsi
callq 0x2c0b5b
leaq 0x7cd(%rip), %rax       # 0x2c771d
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
leaq 0x14cf(%rip), %rax      # 0x2c842f
movq %rax, 0x18(%rdi)
movw $0x0, 0x24(%rdi)
movq %rbx, %rsi
callq 0x2c0b5b
cmpl $0x0, 0x30(%r14)
jne 0x2c6fee
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2c6fee
leaq -0x241a(%rip), %rax     # 0x2c4b6f
leaq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq -0xcad(%rip), %rax      # 0x2c62ec
movq %rax, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq %r14, (%rdi)
movq %r15, 0x28(%rdi)
movq %rbx, %rsi
callq 0x2c0b5b
cmpl $0x0, 0x30(%r14)
jne 0x2c6fee
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2c6fee
leaq 0x2500(%rip), %rax      # 0x2c94cb
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
leaq 0x24f3(%rip), %rax      # 0x2c94ce
movq %rax, 0x18(%rdi)
movq %r12, 0x8(%rdi)
movq %r14, (%rdi)
movq %rbx, %rsi
callq 0x2c0b5b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c71ec
movb (%rsi), %al
addb $0x7b, %al
cmpb $0x2, %al
ja 0x2c71fa
movzbl %al, %eax
leaq 0x1f1122(%rip), %rcx    # 0x4b8308
movq (%rcx,%rax,8), %rdx
jmp 0x2c7201
leaq 0x110db7(%rip), %rsi    # 0x3d7faa
xorl %eax, %eax
jmp 0x27b48d
leaq 0x110e44(%rip), %rdx    # 0x3d8045
leaq 0x110dd0(%rip), %rsi    # 0x3d7fd8
xorl %eax, %eax
jmp 0x27b48d
// File: /workspace/github_c_makefile_star2_O3/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 0x2c8443
cmpq $0x0, 0x50(%rsi)
je 0x2c8444
retq
movq %rsi, %rcx
movq 0x58(%rsi), %rsi
testq %rsi, %rsi
jne 0x2c8444
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
je 0x2c8443
movq 0x8(%rcx), %rcx
movq %rcx, 0x190(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c8502
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0x18(%rax), %r9
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r10      # imm = 0x100000000
addq %r10, %r8
leaq 0x20(%r9), %r11
cmpq %rcx, (%r9)
movq %r11, %r9
jne 0x2c84ea
sarq $0x1b, %r8
addq %r8, %rax
jmp 0x2c8506
leaq 0x8(%rdx), %rax
movq (%rax), %rcx
movq 0x10(%rdx), %rdx
jmp 0x27b1c7
// File: /workspace/github_c_makefile_star2_O3/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), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x2c886a
testb $0x2, 0x3d(%rsi)
je 0x2c886a
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rsi), %rdx
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x2c8845
leaq 0x108acf(%rip), %rcx    # 0x3d12e0
movq (%rax), %rdi
xorl %r8d, %r8d
movzbl (%rdi,%r8), %r9d
movzbl (%rdx,%r8), %r10d
cmpb %r10b, %r9b
jne 0x2c882d
testq %r9, %r9
jne 0x2c8837
jmp 0x2c8863
movb (%r9,%rcx), %r9b
cmpb (%r10,%rcx), %r9b
jne 0x2c883c
incq %r8
jmp 0x2c8817
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x2c8811
leaq 0x10f64c(%rip), %rsi    # 0x3d7e98
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x27b48d
movb $0x1, 0x1d(%rbx)
movl $0x1, %eax
jmp 0x2c8869
movq %rax, 0x68(%rsi)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: 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 0x2c8b7c
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 0x2c936a
testl %eax, %eax
js 0x2c8b6c
testl %ebp, %ebp
je 0x2c8b80
movq 0x8(%r13), %rcx
movl %eax, %edx
shlq $0x5, %rdx
testb $0x2, 0x1c(%rcx,%rdx)
je 0x2c8b80
incq %rbx
addq $0x70, %r12
cmpq %rbx, %r14
jne 0x2c8b44
xorl %ecx, %ecx
jmp 0x2c8b98
xorl %ecx, %ecx
jmp 0x2c8ba6
movl $0x1, %ecx
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x2c8b98
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_O3/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 0x2c9369
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 0x2c934a
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x2c934a
cmpl $0x0, (%rax)
jle 0x2c934a
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%rax,%r15), %rdi
movl %ebx, %esi
callq 0x2c92f3
incq %r12
movq 0x20(%r14), %rax
movslq (%rax), %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0x2c932c
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x2c92f3
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x2c9305
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: columnIndex
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 %r14
pushq %rbx
testq %rsi, %rsi
je 0x2c9397
movb (%rsi), %dl
testb %dl, %dl
je 0x2c9397
leaq 0x1(%rsi), %rax
xorl %ecx, %ecx
leaq 0x107f5b(%rip), %r8     # 0x3d12e0
movzbl %dl, %edx
addb (%rdx,%r8), %cl
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x2c9385
jmp 0x2c9399
xorl %ecx, %ecx
movswl 0x46(%rdi), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x2c93f2
movq 0x8(%rdi), %r8
xorl %edi, %edi
leaq 0x107f2d(%rip), %r9     # 0x3d12e0
cmpb %cl, 0x1b(%r8)
jne 0x2c93e4
movq (%r8), %r10
xorl %r11d, %r11d
movzbl (%r10,%r11), %ebx
movzbl (%rsi,%r11), %r14d
cmpb %r14b, %bl
jne 0x2c93d5
testq %rbx, %rbx
jne 0x2c93df
jmp 0x2c93f0
movb (%rbx,%r9), %bl
cmpb (%r14,%r9), %bl
jne 0x2c93e4
incq %r11
jmp 0x2c93bf
addq $0x20, %r8
incl %edi
cmpl %edx, %edi
jne 0x2c93b3
jmp 0x2c93f2
movl %edi, %eax
popq %rbx
popq %r14
retq