// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: selectExpander
static int selectExpander(Walker *pWalker, Select *p){
  Parse *pParse = pWalker->pParse;
  int i, j, k;
  SrcList *pTabList;
  ExprList *pEList;
  struct SrcList_item *pFrom;
  sqlite3 *db = pParse->db;
  Expr *pE, *pRight, *pExpr;
  u16 selFlags = p->selFlags;
  u32 elistFlags = 0;

  p->selFlags |= SF_Expanded;
  if( db->mallocFailed  ){
    return WRC_Abort;
  }
  assert( p->pSrc!=0 );
  if( (selFlags & SF_Expanded)!=0 ){
    return WRC_Prune;
  }
  if( pWalker->eCode ){
    /* Renumber selId because it has been copied from a view */
    p->selId = ++pParse->nSelect;
  }
  pTabList = p->pSrc;
  pEList = p->pEList;
  sqlite3WithPush(pParse, p->pWith, 0);

  /* Make sure cursor numbers have been assigned to all entries in
  ** the FROM clause of the SELECT statement.
  */
  sqlite3SrcListAssignCursors(pParse, pTabList);

  /* Look up every table named in the FROM clause of the select.  If
  ** an entry of the FROM clause is a subquery instead of a table or view,
  ** then create a transient table structure to describe the subquery.
  */
  for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
    Table *pTab;
    assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
    if( pFrom->pTab ) continue;
    assert( pFrom->fg.isRecursive==0 );
#ifndef SQLITE_OMIT_CTE
    if( withExpand(pWalker, pFrom) ) return WRC_Abort;
    if( pFrom->pTab ) {} else
#endif
    if( pFrom->zName==0 ){
#ifndef SQLITE_OMIT_SUBQUERY
      Select *pSel = pFrom->pSelect;
      /* A sub-query in the FROM clause of a SELECT */
      assert( pSel!=0 );
      assert( pFrom->pTab==0 );
      if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
      if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
#endif
    }else{
      /* An ordinary table or view name in the FROM clause */
      assert( pFrom->pTab==0 );
      pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
      if( pTab==0 ) return WRC_Abort;
      if( pTab->nTabRef>=0xffff ){
        sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
           pTab->zName);
        pFrom->pTab = 0;
        return WRC_Abort;
      }
      pTab->nTabRef++;
      if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
        return WRC_Abort;
      }
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
      if( IsVirtual(pTab) || pTab->pSelect ){
        i16 nCol;
        u8 eCodeOrig = pWalker->eCode;
        if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
        assert( pFrom->pSelect==0 );
        if( pTab->pSelect && (db->flags & SQLITE_EnableView)==0 ){
          sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
            pTab->zName);
        }
#ifndef SQLITE_OMIT_VIRTUALTABLE
        if( IsVirtual(pTab)
         && pFrom->fg.fromDDL
         && ALWAYS(pTab->pVTable!=0)
         && pTab->pVTable->eVtabRisk > ((db->flags & SQLITE_TrustedSchema)!=0)
        ){
          sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"",
                                  pTab->zName);
        }
#endif
        pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
        nCol = pTab->nCol;
        pTab->nCol = -1;
        pWalker->eCode = 1;  /* Turn on Select.selId renumbering */
        sqlite3WalkSelect(pWalker, pFrom->pSelect);
        pWalker->eCode = eCodeOrig;
        pTab->nCol = nCol;
      }
#endif
    }

    /* Locate the index named by the INDEXED BY clause, if any. */
    if( sqlite3IndexedByLookup(pParse, pFrom) ){
      return WRC_Abort;
    }
  }

  /* Process NATURAL keywords, and ON and USING clauses of joins.
  */
  if( pParse->nErr || db->mallocFailed || sqliteProcessJoin(pParse, p) ){
    return WRC_Abort;
  }

  /* For every "*" that occurs in the column list, insert the names of
  ** all columns in all tables.  And for every TABLE.* insert the names
  ** of all columns in TABLE.  The parser inserted a special expression
  ** with the TK_ASTERISK operator for each "*" that it found in the column
  ** list.  The following code just has to locate the TK_ASTERISK
  ** expressions and expand each one to the list of all columns in
  ** all tables.
  **
  ** The first loop just checks to see if there are any "*" operators
  ** that need expanding.
  */
  for(k=0; k<pEList->nExpr; k++){
    pE = pEList->a[k].pExpr;
    if( pE->op==TK_ASTERISK ) break;
    assert( pE->op!=TK_DOT || pE->pRight!=0 );
    assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
    if( pE->op==TK_DOT && pE->pRight->op==TK_ASTERISK ) break;
    elistFlags |= pE->flags;
  }
  if( k<pEList->nExpr ){
    /*
    ** If we get here it means the result set contains one or more "*"
    ** operators that need to be expanded.  Loop through each expression
    ** in the result set and expand them one by one.
    */
    struct ExprList_item *a = pEList->a;
    ExprList *pNew = 0;
    int flags = pParse->db->flags;
    int longNames = (flags & SQLITE_FullColNames)!=0
                      && (flags & SQLITE_ShortColNames)==0;

    for(k=0; k<pEList->nExpr; k++){
      pE = a[k].pExpr;
      elistFlags |= pE->flags;
      pRight = pE->pRight;
      assert( pE->op!=TK_DOT || pRight!=0 );
      if( pE->op!=TK_ASTERISK
       && (pE->op!=TK_DOT || pRight->op!=TK_ASTERISK)
      ){
        /* This particular expression does not need to be expanded.
        */
        pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
        if( pNew ){
          pNew->a[pNew->nExpr-1].zEName = a[k].zEName;
          pNew->a[pNew->nExpr-1].eEName = a[k].eEName;
          a[k].zEName = 0;
        }
        a[k].pExpr = 0;
      }else{
        /* This expression is a "*" or a "TABLE.*" and needs to be
        ** expanded. */
        int tableSeen = 0;      /* Set to 1 when TABLE matches */
        char *zTName = 0;       /* text of name of TABLE */
        if( pE->op==TK_DOT ){
          assert( pE->pLeft!=0 );
          assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
          zTName = pE->pLeft->u.zToken;
        }
        for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
          Table *pTab = pFrom->pTab;
          Select *pSub = pFrom->pSelect;
          char *zTabName = pFrom->zAlias;
          const char *zSchemaName = 0;
          int iDb;
          if( zTabName==0 ){
            zTabName = pTab->zName;
          }
          if( db->mallocFailed ) break;
          if( pSub==0 || (pSub->selFlags & SF_NestedFrom)==0 ){
            pSub = 0;
            if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
              continue;
            }
            iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
            zSchemaName = iDb>=0 ? db->aDb[iDb].zDbSName : "*";
          }
          for(j=0; j<pTab->nCol; j++){
            char *zName = pTab->aCol[j].zName;
            char *zColname;  /* The computed column name */
            char *zToFree;   /* Malloced string that needs to be freed */
            Token sColname;  /* Computed column name as a token */

            assert( zName );
            if( zTName && pSub
             && sqlite3MatchEName(&pSub->pEList->a[j], 0, zTName, 0)==0
            ){
              continue;
            }

            /* If a column is marked as 'hidden', omit it from the expanded
            ** result-set list unless the SELECT has the SF_IncludeHidden
            ** bit set.
            */
            if( (p->selFlags & SF_IncludeHidden)==0
             && IsHiddenColumn(&pTab->aCol[j])
            ){
              continue;
            }
            tableSeen = 1;

            if( i>0 && zTName==0 ){
              if( (pFrom->fg.jointype & JT_NATURAL)!=0
                && tableAndColumnIndex(pTabList, i, zName, 0, 0, 1)
              ){
                /* In a NATURAL join, omit the join columns from the
                ** table to the right of the join */
                continue;
              }
              if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
                /* In a join with a USING clause, omit columns in the
                ** using clause from the table on the right. */
                continue;
              }
            }
            pRight = sqlite3Expr(db, TK_ID, zName);
            zColname = zName;
            zToFree = 0;
            if( longNames || pTabList->nSrc>1 ){
              Expr *pLeft;
              pLeft = sqlite3Expr(db, TK_ID, zTabName);
              pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
              if( zSchemaName ){
                pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
                pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
              }
              if( longNames ){
                zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
                zToFree = zColname;
              }
            }else{
              pExpr = pRight;
            }
            pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
            sqlite3TokenInit(&sColname, zColname);
            sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
            if( pNew && (p->selFlags & SF_NestedFrom)!=0 && !IN_RENAME_OBJECT ){
              struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
              sqlite3DbFree(db, pX->zEName);
              if( pSub ){
                pX->zEName = sqlite3DbStrDup(db, pSub->pEList->a[j].zEName);
                testcase( pX->zEName==0 );
              }else{
                pX->zEName = sqlite3MPrintf(db, "%s.%s.%s",
                                           zSchemaName, zTabName, zColname);
                testcase( pX->zEName==0 );
              }
              pX->eEName = ENAME_TAB;
            }
            sqlite3DbFree(db, zToFree);
          }
        }
        if( !tableSeen ){
          if( zTName ){
            sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
          }else{
            sqlite3ErrorMsg(pParse, "no tables specified");
          }
        }
      }
    }
    sqlite3ExprListDelete(db, pEList);
    p->pEList = pNew;
  }
  if( p->pEList ){
    if( p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
      sqlite3ErrorMsg(pParse, "too many columns in result set");
      return WRC_Abort;
    }
    if( (elistFlags & (EP_HasFunc|EP_Subquery))!=0 ){
      p->selFlags |= SF_ComplexResult;
    }
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq (%rdi), %r12
movq (%r12), %r15
movl 0x4(%rsi), %eax
movl %eax, %ecx
orl $0x40, %ecx
movl %ecx, 0x4(%rsi)
pushq $0x2
popq %rbx
cmpb $0x0, 0x61(%r15)
jne 0x26dfe3
movq %rsi, 0x58(%rsp)
testb $0x40, %al
jne 0x26dd3d
movq %rdi, %rbp
cmpw $0x0, 0x24(%rdi)
movq 0x58(%rsp), %rcx
je 0x26d7f6
movl 0x84(%r12), %eax
incl %eax
movl %eax, 0x84(%r12)
movl %eax, 0x10(%rcx)
movq 0x20(%rcx), %rax
movq %rax, 0x78(%rsp)
movq 0x28(%rcx), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rcx), %rax
testq %rax, %rax
je 0x26d825
movq 0x190(%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x190(%r12)
movq %r12, %rdi
movq 0x70(%rsp), %rbx
movq %rbx, %rsi
callq 0x26e643
addq $0x8, %rbx
movq %rbx, 0xc0(%rsp)
xorl %ecx, %ecx
movq %r12, 0x8(%rsp)
movq %r15, 0x20(%rsp)
movq %rbp, 0x48(%rsp)
movq 0x70(%rsp), %rax
cmpl (%rax), %ecx
jge 0x26dd44
cmpq $0x0, 0x20(%rbx)
jne 0x26dd32
movq (%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x26dfe0
movl %ecx, 0x40(%rsp)
cmpq $0x0, 0x8(%rbx)
je 0x26d9bf
cmpq $0x0, 0x10(%rbx)
je 0x26da3b
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x26e69f
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x26dfe0
movq %rax, %r15
movl 0x3c(%rax), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jae 0x26df95
incl %eax
movl %eax, 0x3c(%r15)
cmpl $0x0, 0x54(%r15)
jne 0x26d8ef
movq %r12, %rdi
movq %rbx, %rsi
callq 0x26e6ef
testl %eax, %eax
jne 0x26dfe0
cmpl $0x0, 0x54(%r15)
jne 0x26d8ef
cmpq $0x0, 0x18(%r15)
je 0x26dd16
movzbl 0x24(%rbp), %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x26e712
testl %eax, %eax
jne 0x26dfe0
cmpq $0x0, 0x18(%r15)
je 0x26d92e
movq 0x20(%rsp), %rax
testb $-0x80, 0x33(%rax)
jne 0x26d92e
movq (%r15), %rdx
movq 0x8(%rsp), %rdi
leaq 0x10a80a(%rip), %rsi    # 0x378131
xorl %eax, %eax
callq 0x226dce
cmpl $0x0, 0x54(%r15)
je 0x26d970
testb $0x40, 0x3d(%rbx)
je 0x26d970
movq 0x60(%r15), %rax
testq %rax, %rax
je 0x26d970
movzbl 0x1d(%rax), %eax
movq 0x20(%rsp), %rcx
movl 0x30(%rcx), %ecx
shrl $0x7, %ecx
andl $0x1, %ecx
cmpl %eax, %ecx
jae 0x26d970
movq (%r15), %rdx
movq 0x8(%rsp), %rdi
leaq 0x10a7e7(%rip), %rsi    # 0x378150
xorl %eax, %eax
callq 0x226dce
movq 0x18(%r15), %rsi
movq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x269b29
movq %rax, 0x28(%rbx)
movzwl 0x46(%r15), %r14d
orw $-0x1, 0x46(%r15)
movq 0x48(%rsp), %r12
movw $0x1, 0x24(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x268025
movw %bp, 0x24(%r12)
movq %r12, %rbp
movw %r14w, 0x46(%r15)
movq 0x8(%rsp), %r12
jmp 0x26dd16
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x26d887
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
leaq 0x190(%rax), %r13
movq %r13, (%rsp)
movq %rax, 0x18(%rsp)
movq (%r13), %r13
testq %r13, %r13
je 0x26d887
movl (%r13), %ebp
testl %ebp, %ebp
movl $0x0, %eax
cmovlel %eax, %ebp
shlq $0x5, %rbp
addq $0x20, %rbp
xorl %ecx, %ecx
leaq 0x20(%rcx), %r14
cmpq %r14, %rbp
je 0x26da2b
movq 0x10(%r13,%rcx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x221779
movq %r14, %rcx
testl %eax, %eax
jne 0x26da09
jmp 0x26da93
addq $0x8, %r13
movq 0x8(%rsp), %r12
movq 0x48(%rsp), %rbp
jmp 0x26d9e4
movq 0x28(%rbx), %rsi
movq %rbp, %rdi
callq 0x268025
testl %eax, %eax
jne 0x26dfe0
movq 0x28(%rbx), %r14
movq (%r12), %rdi
movl $0x80, %esi
callq 0x2258ed
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x26dfe0
movq %rax, %r15
movl $0x1, 0x3c(%rax)
movq 0x18(%rbx), %rsi
movq (%r12), %rdi
testq %rsi, %rsi
je 0x26dc02
callq 0x22572a
jmp 0x26dc14
movq 0x8(%r13,%r14), %rsi
testq %rsi, %rsi
jne 0x26dfbe
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x26e6ef
testl %eax, %eax
jne 0x26dfe0
movl $0x80, %esi
movq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x2258ed
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x26dfe0
movq %rax, %r15
movl $0x1, 0x3c(%rax)
movq -0x10(%r13,%r14), %rsi
movq %r12, %rdi
callq 0x22572a
movq %rax, (%r15)
orw $-0x1, 0x44(%r15)
movw $0xc8, 0x4a(%r15)
orl $0x202, 0x40(%r15)      # imm = 0x202
movq (%r13,%r14), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x269b29
movq %rax, 0x28(%rbx)
cmpb $0x0, 0x61(%r12)
jne 0x26dfe0
movq %r15, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movb (%rax), %al
andb $-0x2, %al
movb %al, 0x30(%rsp)
cmpb $-0x7c, %al
jne 0x26dba0
movq 0x10(%rsp), %rax
movq 0x28(%rax), %r12
movl (%r12), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
imulq $0x70, %rax, %rbp
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x26dba0
cmpq $0x0, 0x10(%r12,%r15)
je 0x26db6a
addq $0x70, %r15
jmp 0x26db57
movq 0x18(%r12,%r15), %rdi
testq %rdi, %rdi
je 0x26db64
movq -0x10(%r13,%r14), %rsi
callq 0x221779
testl %eax, %eax
jne 0x26db64
movq 0x38(%rsp), %rax
movq %rax, 0x28(%r12,%r15)
orb $0x20, 0x45(%r12,%r15)
incl 0x3c(%rax)
movq 0x10(%rsp), %rax
orb $0x20, 0x5(%rax)
jmp 0x26db64
movq 0x38(%rsp), %rax
cmpl $0x3, 0x3c(%rax)
jae 0x26dfc8
leaq 0x10a62b(%rip), %rax    # 0x3781e1
movq %rax, 0x8(%r13,%r14)
movq (%rsp), %rcx
movq (%rcx), %rax
movq %rax, 0x88(%rsp)
movq %r13, (%rcx)
cmpb $-0x7c, 0x30(%rsp)
jne 0x26dc5d
movq 0x10(%rsp), %r15
movq 0x50(%r15), %r12
movq 0x68(%r15), %rax
movq %rax, 0x68(%r12)
movq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x268025
andq $0x0, 0x68(%r12)
jmp 0x26dc72
movl 0x10(%r14), %edx
leaq 0x10a66a(%rip), %rsi    # 0x378277
xorl %eax, %eax
callq 0x226ec3
movq %rax, (%r15)
movq %r14, %rax
movq 0x50(%r14), %r14
testq %r14, %r14
jne 0x26dc17
movq 0x20(%rax), %rsi
leaq 0x46(%r15), %rdx
movq %r15, %rcx
addq $0x8, %rcx
movq %r12, %rdi
callq 0x26eb22
orw $-0x1, 0x44(%r15)
movw $0xc8, 0x4a(%r15)
orb $0x2, 0x40(%r15)
cmpl $0x0, 0x30(%r12)
je 0x26dd16
jmp 0x26dfe0
movq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x268025
movq 0x8(%rsp), %r12
movq (%rsp), %rax
movq %r13, (%rax)
movq %r15, %rax
movq 0x50(%r15), %r15
testq %r15, %r15
jne 0x26dc7e
movq 0x20(%rax), %rax
movq -0x8(%r13,%r14), %rsi
testq %rsi, %rsi
je 0x26dcac
testq %rax, %rax
je 0x26dcaf
movl (%rax), %ecx
movl (%rsi), %r8d
cmpl %r8d, %ecx
je 0x26dcaf
jmp 0x26dff7
movq %rax, %rsi
movq 0x38(%rsp), %rcx
leaq 0x46(%rcx), %rdx
addq $0x8, %rcx
movq 0x18(%rsp), %rdi
callq 0x26eb22
cmpb $-0x7c, 0x30(%rsp)
jne 0x26dcf6
movq 0x10(%rsp), %rsi
btl $0xd, 0x4(%rsi)
leaq 0x10a540(%rip), %rax    # 0x37821e
leaq 0x10a55b(%rip), %rcx    # 0x378240
cmovaeq %rcx, %rax
movq %rax, 0x8(%r13,%r14)
movq %rbp, %rdi
callq 0x268025
andq $0x0, 0x8(%r13,%r14)
movq 0x88(%rsp), %rax
movq (%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, 0x20(%rbx)
je 0x26d887
movq %r12, %rdi
movq %rbx, %rsi
callq 0x26e9bf
testl %eax, %eax
movq 0x20(%rsp), %r15
movl 0x40(%rsp), %ecx
jne 0x26dfe0
incl %ecx
addq $0x70, %rbx
jmp 0x26d852
pushq $0x1
jmp 0x26dfe2
cmpl $0x0, 0x30(%r12)
pushq $0x2
popq %rbx
jne 0x26dfe3
cmpb $0x0, 0x61(%r15)
jne 0x26dfe3
movq 0x58(%rsp), %rax
movq 0x28(%rax), %r14
leaq 0x8(%r14), %rcx
leaq 0x78(%r14), %rdx
movq %rdx, (%rsp)
addq $0x30, %rax
movq %rax, 0x40(%rsp)
xorl %edx, %edx
movl (%r14), %eax
decl %eax
cmpl %eax, %edx
jge 0x26e023
movq %rdx, 0x18(%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rdx
movq %rcx, 0x30(%rsp)
cmpq $0x0, 0x20(%rcx)
sete %al
movq %rdx, 0x38(%rsp)
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x26dede
movq %r14, %rbp
movq (%rsp), %rax
movzbl 0x3c(%rax), %eax
movl %eax, %ecx
andl $0x20, %ecx
movl %ecx, 0x10(%rsp)
shrl $0x5, %ecx
movq %rcx, 0x48(%rsp)
testb $0x4, %al
pushq $0x1
popq %r14
movq 0x38(%rsp), %r13
jne 0x26df00
movq (%rsp), %rbx
movq 0x48(%rbx), %rdx
testq %rdx, %rdx
movq %rbp, %r14
je 0x26de30
cmpq $0x0, 0x50(%rbx)
jne 0x26e5f8
cmpl $0x0, 0x10(%rsp)
je 0x26de16
movl 0x40(%rbx), %esi
movq %rdx, %rdi
callq 0x26f0e4
movq 0x48(%rbx), %rdx
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %r15
movq (%r15), %rsi
callq 0x26119e
movq %rax, (%r15)
andq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x26dede
movq 0x18(%rsp), %rax
leal 0x1(%rax), %ebx
xorl %edx, %edx
xorl %r13d, %r13d
movq %rcx, 0x10(%rsp)
movslq 0x8(%rcx), %rax
cmpq %rax, %r13
jge 0x26dede
movq (%rcx), %rax
movq %rdx, %r15
movq (%rax,%rdx), %r12
movq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x26f155
testl %eax, %eax
js 0x26dfb0
movl %eax, %ebp
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
leaq 0x90(%rsp), %rcx
leaq 0x64(%rsp), %r8
xorl %r9d, %r9d
callq 0x26ea33
testl %eax, %eax
je 0x26dfb0
movl 0x90(%rsp), %edx
movl 0x64(%rsp), %ecx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %r8d
movl %ebp, %r9d
pushq 0x40(%rsp)
pushq 0x50(%rsp)
callq 0x26f057
popq %rax
popq %rcx
incq %r13
movq %r15, %rdx
addq $0x10, %rdx
movq 0x10(%rsp), %rcx
jmp 0x26de4f
movq 0x18(%rsp), %rdx
incl %edx
addq $0x70, (%rsp)
movq 0x30(%rsp), %rcx
addq $0x70, %rcx
pushq $0x2
popq %rbx
movq 0x20(%rsp), %r15
jmp 0x26dd7e
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x26e5c4
cmpq $0x0, 0x50(%rax)
jne 0x26e5c4
movq 0x18(%rsp), %rax
leal 0x1(%rax), %r15d
xorl %ebx, %ebx
xorl %r12d, %r12d
movswq 0x46(%r13), %rax
cmpq %rax, %r12
jge 0x26dde5
movq 0x8(%r13), %rax
testb $0x2, 0x1c(%rax,%rbx)
jne 0x26df8c
movq (%rax,%rbx), %rdx
movq %rbp, %rdi
movl %r15d, %esi
leaq 0x90(%rsp), %rcx
leaq 0x64(%rsp), %r8
movl %r14d, %r9d
callq 0x26ea33
testl %eax, %eax
je 0x26df8c
movl 0x90(%rsp), %edx
movl 0x64(%rsp), %ecx
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movl %r15d, %r8d
movl %r12d, %r9d
pushq 0x40(%rsp)
pushq 0x50(%rsp)
callq 0x26f057
popq %rax
popq %rcx
incq %r12
addq $0x20, %rbx
jmp 0x26df28
movq (%r15), %rdx
leaq 0x10a16b(%rip), %rsi    # 0x37810a
movq %r12, %rdi
xorl %eax, %eax
callq 0x226dce
andq $0x0, 0x20(%rbx)
jmp 0x26dfe0
leaq 0x10a37c(%rip), %rsi    # 0x378333
movq 0x8(%rsp), %rdi
jmp 0x26dfc3
movq 0x18(%rsp), %rdi
movq %r12, %rdx
jmp 0x26dfd9
movq -0x10(%r13,%r14), %rdx
leaq 0x10a1e2(%rip), %rsi    # 0x3781b6
movq 0x18(%rsp), %rdi
xorl %eax, %eax
callq 0x226dce
pushq $0x2
popq %rbx
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x10(%r13,%r14), %rdx
leaq 0x10a1f5(%rip), %rsi    # 0x3781f8
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x226dce
movq 0x88(%rsp), %rax
movq %rax, 0x190(%rbx)
jmp 0x26dfe0
movq 0x78(%rsp), %rcx
movl (%rcx), %eax
addq $0x8, %rcx
movq %rcx, 0xa0(%rsp)
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
imulq $0x18, %rdx, %rdx
movl $0x0, 0x2c(%rsp)
movq 0x8(%rsp), %r14
cmpq %rcx, %rdx
je 0x26e091
movq 0x78(%rsp), %rsi
movq 0x8(%rsi,%rcx), %rsi
movzbl (%rsi), %edi
cmpl $0x8b, %edi
je 0x26e077
cmpl $0xb1, %edi
jne 0x26e080
jmp 0x26e09f
movq 0x18(%rsi), %rdi
cmpb $-0x4f, (%rdi)
je 0x26e09f
movl 0x2c(%rsp), %edi
orl 0x4(%rsi), %edi
movl %edi, 0x2c(%rsp)
addq $0x18, %rcx
jmp 0x26e053
movq 0x58(%rsp), %rax
movq 0x20(%rax), %r12
jmp 0x26e59c
movq (%r14), %rcx
movq 0x30(%rcx), %rcx
andl $0x44, %ecx
movq %rcx, 0x18(%rsp)
xorl %ecx, %ecx
xorl %r12d, %r12d
cltq
cmpq %rax, %rcx
jge 0x26e586
movq %rcx, 0xb8(%rsp)
imulq $0x18, %rcx, %rbx
movq 0xa0(%rsp), %rax
movq (%rax,%rbx), %rdx
movl 0x2c(%rsp), %eax
orl 0x4(%rdx), %eax
movl %eax, 0x2c(%rsp)
movzbl (%rdx), %eax
cmpl $0xb1, %eax
je 0x26e156
cmpl $0x8b, %eax
jne 0x26e105
movq 0x18(%rdx), %rax
cmpb $-0x4f, (%rax)
jne 0x26e105
movq 0x10(%rdx), %rax
movq 0x8(%rax), %r13
jmp 0x26e159
addq 0xa0(%rsp), %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x25bc95
movq %rax, %r12
testq %rax, %rax
je 0x26e14a
movq 0x8(%rbx), %rax
movslq (%r12), %rcx
imulq $0x18, %rcx, %rcx
movq %rax, -0x8(%rcx,%r12)
movb 0x11(%rbx), %al
andb $0x3, %al
movb 0x1(%rcx,%r12), %dl
andb $-0x4, %dl
orb %al, %dl
movb %dl, 0x1(%rcx,%r12)
andq $0x0, 0x8(%rbx)
andq $0x0, (%rbx)
pushq $0x2
popq %rbx
jmp 0x26e56f
xorl %r13d, %r13d
movl $0x0, (%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x30(%rsp)
xorl %ecx, %ecx
pushq $0x2
popq %rbx
movq %r13, 0xa8(%rsp)
movq 0x70(%rsp), %rax
cmpl (%rax), %ecx
jge 0x26e534
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rbp
movq %rdx, 0x68(%rsp)
testq %rdx, %rdx
jne 0x26e1a7
movq (%rbp), %rax
movq %rax, 0x68(%rsp)
movq 0x20(%rsp), %rax
cmpb $0x0, 0x61(%rax)
jne 0x26e534
movl %ecx, 0x54(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x26e1ce
testb $0x8, 0x5(%rdx)
jne 0x26e220
testq %r13, %r13
je 0x26e1e8
movq %r13, %rdi
movq 0x68(%rsp), %rsi
callq 0x221779
testl %eax, %eax
jne 0x26e523
movq 0x70(%rbp), %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x226e9e
testl %eax, %eax
pushq $0x1
popq %r14
movq %r12, 0x10(%rsp)
js 0x26e237
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
movq %rax, 0x80(%rsp)
xorl %edx, %edx
jmp 0x26e248
movq %r12, 0x10(%rsp)
movq $0x0, 0x80(%rsp)
pushq $0x1
popq %r14
jmp 0x26e248
xorl %edx, %edx
leaq 0xfc390(%rip), %rax     # 0x36a5d0
movq %rax, 0x80(%rsp)
testq %r13, %r13
setne %al
sete %cl
movq %rdx, 0xb0(%rsp)
testq %rdx, %rdx
setne %dl
andb %al, %dl
movb %dl, 0x38(%rsp)
cmpl $0x0, 0x54(%rsp)
setne %al
andb %cl, %al
movb %al, 0x88(%rsp)
xorl %ebx, %ebx
pushq $0x8
popq %rcx
xorl %r13d, %r13d
movq %rbp, 0x48(%rsp)
movswq 0x46(%rbp), %rax
cmpq %rax, %r13
jge 0x26e50e
movq 0x8(%rbp), %r12
movq (%r12,%rbx), %rbp
cmpb $0x0, 0x38(%rsp)
je 0x26e2ce
movq 0xb0(%rsp), %rax
movq 0x20(%rax), %rdi
addq %rcx, %rdi
xorl %esi, %esi
movq 0xa8(%rsp), %rdx
movq %rcx, %r15
xorl %ecx, %ecx
callq 0x26cf9c
movq %r15, %rcx
testl %eax, %eax
je 0x26e4f9
movq 0x58(%rsp), %rax
testb $0x2, 0x6(%rax)
jne 0x26e2e5
testb $0x2, 0x1c(%r12,%rbx)
jne 0x26e4f9
movq %rcx, 0x40(%rsp)
cmpb $0x0, 0x88(%rsp)
movq 0x20(%rsp), %r15
je 0x26e33e
movq 0x30(%rsp), %rax
testb $0x4, 0x3c(%rax)
je 0x26e325
movq 0x70(%rsp), %rdi
movl 0x54(%rsp), %esi
movq %rbp, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl %r14d, %r9d
callq 0x26ea33
testl %eax, %eax
jne 0x26e4f0
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movq %rbp, %rsi
callq 0x26eac5
testl %eax, %eax
jns 0x26e4f0
movq %r15, %rdi
pushq $0x3b
popq %rsi
movq %rbp, %rdx
callq 0x25bd93
movq %rax, %r12
cmpl $0x4, 0x18(%rsp)
je 0x26e364
movq 0x70(%rsp), %rax
cmpl $0x2, (%rax)
jl 0x26e3ef
movq %r15, %rdi
pushq $0x3b
popq %rsi
movq 0x68(%rsp), %rdx
callq 0x25bd93
movq %r15, %r14
movq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x8b, %esi
movq %rax, %rdx
movq %r12, %rcx
callq 0x254915
movq %rax, %r12
movq 0x80(%rsp), %rdx
testq %rdx, %rdx
je 0x26e3c0
movq %r14, %rdi
pushq $0x3b
popq %rsi
callq 0x25bd93
movq %r15, %rdi
movl $0x8b, %esi
movq %rax, %rdx
movq %r12, %rcx
callq 0x254915
movq %rax, %r12
cmpl $0x4, 0x18(%rsp)
pushq $0x1
popq %r14
jne 0x26e3ef
movq 0x20(%rsp), %rdi
leaq 0x8671e(%rip), %rsi     # 0x2f4af5
movq 0x68(%rsp), %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x226ec3
movq %rax, %rbp
movq %rax, (%rsp)
jmp 0x26e3f7
movq $0x0, (%rsp)
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x25bc95
movq %rax, %r12
movq %rbp, 0x90(%rsp)
movq %rbp, %rdi
callq 0x2211ac
movl %eax, 0x98(%rsp)
movq %r15, %rdi
movq %r12, %rsi
leaq 0x90(%rsp), %rdx
xorl %ecx, %ecx
callq 0x25bd24
movq %r12, 0x10(%rsp)
testq %r12, %r12
movq 0x20(%rsp), %r15
je 0x26e4e4
movq 0x58(%rsp), %rax
testb $0x8, 0x5(%rax)
je 0x26e4e4
movq 0x8(%rsp), %rax
cmpb $0x1, 0x11c(%rax)
ja 0x26e4e4
movq 0x10(%rsp), %rcx
movslq (%rcx), %rax
imulq $0x18, %rax, %r12
movq -0x8(%r12,%rcx), %rsi
movq %r15, %rdi
callq 0x21f26b
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x26e4a9
movq 0x20(%rax), %rax
movq 0x40(%rsp), %rcx
movq 0x8(%rax,%rcx), %rsi
movq %r15, %rdi
callq 0x22572a
jmp 0x26e4ca
movq %r15, %rdi
leaq 0x109b1b(%rip), %rsi    # 0x377fce
movq 0x80(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x226ec3
movq 0x10(%rsp), %rcx
addq %r12, %rcx
addq $-0x10, %rcx
movq %rax, 0x8(%rcx)
movb 0x11(%rcx), %al
andb $-0x4, %al
orb $0x2, %al
movb %al, 0x11(%rcx)
movq %r15, %rdi
movq (%rsp), %rsi
callq 0x21f26b
movl %r14d, (%rsp)
movq 0x40(%rsp), %rcx
incq %r13
addq $0x18, %rcx
addq $0x20, %rbx
movq 0x48(%rsp), %rbp
jmp 0x26e283
pushq $0x2
popq %rbx
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r12
movq 0xa8(%rsp), %r13
movl 0x54(%rsp), %ecx
incl %ecx
addq $0x70, 0x30(%rsp)
jmp 0x26e17a
cmpl $0x0, (%rsp)
je 0x26e541
movq 0x20(%rsp), %r15
jmp 0x26e56f
testq %r13, %r13
movq 0x20(%rsp), %r15
movq %r14, %rdi
je 0x26e561
leaq 0x109c1c(%rip), %rsi    # 0x378171
movq %r13, %rdx
xorl %eax, %eax
callq 0x226dce
jmp 0x26e56f
leaq 0x109c1b(%rip), %rsi    # 0x378183
xorl %eax, %eax
callq 0x226dce
movq 0xb8(%rsp), %rcx
incq %rcx
movq 0x78(%rsp), %rax
movl (%rax), %eax
jmp 0x26e0b3
movq %r15, %rdi
movq 0x78(%rsp), %rsi
callq 0x24b9fb
movq 0x58(%rsp), %rax
movq %r12, 0x20(%rax)
testq %r12, %r12
je 0x26e5f1
movl (%r12), %eax
cmpl 0x84(%r15), %eax
jle 0x26e5de
leaq 0x109be2(%rip), %rsi    # 0x378197
movq %r14, %rdi
xorl %eax, %eax
callq 0x226dce
jmp 0x26dfe3
leaq 0x109cff(%rip), %rsi    # 0x3782ca
movq 0x8(%rsp), %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x226dce
jmp 0x26dfe0
testl $0x200004, 0x2c(%rsp)   # imm = 0x200004
je 0x26e5f1
movq 0x58(%rsp), %rax
orb $0x4, 0x6(%rax)
xorl %ebx, %ebx
jmp 0x26dfe3
leaq 0x109cfd(%rip), %rsi    # 0x3782fc
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x226dce
jmp 0x26dfe0