// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/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;

  p->selFlags |= SF_Expanded;
  if( db->mallocFailed  ){
    return WRC_Abort;
  }
  if( NEVER(p->pSrc==0) || (selFlags & SF_Expanded)!=0 ){
    return WRC_Prune;
  }
  pTabList = p->pSrc;
  pEList = p->pEList;
  if( pWalker->xSelectCallback2==selectPopWith ){
    sqlite3WithPush(pParse, findRightmost(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->fg.isRecursive ) continue;
    assert( pFrom->pTab==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;
      pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
      if( pTab==0 ) return WRC_Abort;
      pTab->nRef = 1;
      pTab->zName = sqlite3MPrintf(db, "sqlite_sq_%p", (void*)pTab);
      while( pSel->pPrior ){ pSel = pSel->pPrior; }
      sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
      pTab->iPKey = -1;
      pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
      pTab->tabFlags |= TF_Ephemeral;
#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->nRef==0xffff ){
        sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
           pTab->zName);
        pFrom->pTab = 0;
        return WRC_Abort;
      }
      pTab->nRef++;
      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;
        if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
        assert( pFrom->pSelect==0 );
        pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
        sqlite3SelectSetName(pFrom->pSelect, pTab->zName);
        nCol = pTab->nCol;
        pTab->nCol = -1;
        sqlite3WalkSelect(pWalker, pFrom->pSelect);
        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( 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;
  }
  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;
      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].zName = a[k].zName;
          pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan;
          a[k].zName = 0;
          a[k].zSpan = 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].zName : "*";
          }
          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
             && sqlite3MatchSpanName(pSub->pEList->a[j].zSpan, 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)
              ){
                /* 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, 0);
              if( zSchemaName ){
                pLeft = sqlite3Expr(db, TK_ID, zSchemaName);
                pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr, 0);
              }
              if( longNames ){
                zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
                zToFree = zColname;
              }
            }else{
              pExpr = pRight;
            }
            pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
            sColname.z = zColname;
            sColname.n = sqlite3Strlen30(zColname);
            sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
            if( pNew && (p->selFlags & SF_NestedFrom)!=0 ){
              struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
              if( pSub ){
                pX->zSpan = sqlite3DbStrDup(db, pSub->pEList->a[j].zSpan);
                testcase( pX->zSpan==0 );
              }else{
                pX->zSpan = sqlite3MPrintf(db, "%s.%s.%s",
                                           zSchemaName, zTabName, zColname);
                testcase( pX->zSpan==0 );
              }
              pX->bSpanIsTab = 1;
            }
            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 SQLITE_MAX_COLUMN
  if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
    sqlite3ErrorMsg(pParse, "too many columns in result set");
    return WRC_Abort;
  }
#endif
  return WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq 0x18(%rdi), %r12
movq (%r12), %rdx
movzwl 0xa(%rsi), %eax
movl %eax, %ecx
orl $0x20, %ecx
movw %cx, 0xa(%rsi)
cmpb $0x0, 0x51(%rdx)
je 0x58e4e
movl $0x2, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r15
movq %rdx, -0x88(%rbp)
movq 0x28(%rsi), %r13
testq %r13, %r13
setne %cl
testb $0x20, %al
sete %dl
andb %cl, %dl
movl $0x1, %eax
cmpb $0x1, %dl
jne 0x58e3c
movq (%r15), %rax
movq %rax, -0xb8(%rbp)
leaq 0x1001(%rip), %rax      # 0x59e85
cmpq %rax, 0x10(%rdi)
jne 0x58eb6
movq %r15, %rcx
movq %rcx, %rax
movq 0x58(%rcx), %rcx
testq %rcx, %rcx
jne 0x58e8d
movq 0x70(%rax), %rax
testq %rax, %rax
je 0x58eb6
movq 0x280(%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x280(%r12)
movq %rdi, -0x70(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x59eaf
leaq 0x8(%r13), %rax
movq %rax, -0xd8(%rbp)
cmpl $0x0, (%r13)
movq %r12, -0x68(%rbp)
movq %r15, -0x60(%rbp)
movq %r13, -0xa8(%rbp)
jle 0x59519
xorl %eax, %eax
movq -0xd8(%rbp), %rdx
movb 0x3d(%rdx), %cl
movl $0x4, %r14d
testb $0x20, %cl
jne 0x59314
movl %eax, -0x38(%rbp)
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rbx
cmpq $0x0, 0x8(%rdx)
movq %rdx, -0x30(%rbp)
je 0x58f3e
xorl %eax, %eax
testq %rax, %rax
je 0x592f8
movq 0x18(%rax), %rsi
testq %rsi, %rsi
je 0x5902b
movq (%rax), %rdx
jmp 0x59168
movq 0x10(%rdx), %r14
testq %r14, %r14
je 0x58f1e
movq 0x280(%rdi), %r12
testq %r12, %r12
sete %al
je 0x5917e
movb %al, -0x48(%rbp)
movb %cl, -0x90(%rbp)
movq %rbx, -0x98(%rbp)
movq %rdi, -0x58(%rbp)
movslq (%r12), %rbx
testq %rbx, %rbx
setg %al
jle 0x58fe7
movq 0x10(%r12), %rsi
movq %r14, %rdi
callq 0xa3f0
testl %eax, %eax
je 0x58fd4
leaq 0x30(%r12), %r13
movl $0x1, %ecx
movq %rcx, %r15
cmpq %rcx, %rbx
je 0x58fc1
movq (%r13), %rsi
movq %r14, %rdi
callq 0xa3f0
leaq 0x1(%r15), %rcx
addq $0x20, %r13
testl %eax, %eax
jne 0x58f95
addq $-0x20, %r13
movq %r12, -0x40(%rbp)
movq %r13, -0x50(%rbp)
cmpq %rbx, %r15
setb %al
movq -0x60(%rbp), %r15
movq -0xa8(%rbp), %r13
jmp 0x58fe3
leaq 0x10(%r12), %rax
movq %rax, -0x50(%rbp)
movb $0x1, %al
movq %r12, -0x40(%rbp)
movq -0x30(%rbp), %rdx
testb %al, %al
jne 0x58ffd
movq 0x8(%r12), %r12
testq %r12, %r12
sete -0x48(%rbp)
jne 0x58f6e
testb $0x1, -0x48(%rbp)
movl $0x0, %eax
movq -0x50(%rbp), %rcx
cmovneq %rax, %rcx
movq %rcx, %rax
movq -0x68(%rbp), %r12
movq -0x58(%rbp), %rdi
movq -0x98(%rbp), %rbx
movb -0x90(%rbp), %cl
jmp 0x58f20
testb $0x4, %cl
jne 0x5915d
movq %rax, -0x50(%rbp)
movq %rdi, -0x58(%rbp)
movl $0x78, %esi
movq %rbx, %rdi
callq 0x144ee
movq %rbx, %r15
movq %rax, %rbx
testq %rax, %rax
je 0x59189
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x70(%rbx)
movq -0x30(%rbp), %rax
movq %rbx, 0x20(%rax)
movw $0x1, 0x40(%rbx)
movq -0x50(%rbp), %r14
movq (%r14), %rsi
movq %r15, %rdi
callq 0x12d08
movq %rax, (%rbx)
movw $0xffff, 0x3c(%rbx)     # imm = 0xFFFF
movw $0xc8, 0x42(%rbx)
orb $0x42, 0x46(%rbx)
movq 0x10(%r14), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x54d2a
movq -0x30(%rbp), %rdx
movq %rax, 0x28(%rdx)
movl $0x1, %r14d
cmpb $0x0, 0x51(%r15)
jne 0x59197
movq %rax, -0x48(%rbp)
movb 0x8(%rax), %al
addb $-0x73, %al
movb %al, -0x98(%rbp)
cmpb $0x1, %al
movq -0x60(%rbp), %r15
ja 0x591a3
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rcx
cmpl $0x0, (%rcx)
jle 0x591a3
leaq 0x45(%rcx), %r13
xorl %r12d, %r12d
cmpq $0x0, -0x35(%r13)
je 0x59123
incq %r12
movslq (%rcx), %rax
addq $0x70, %r13
cmpq %rax, %r12
jl 0x59108
jmp 0x591a3
movq -0x2d(%r13), %rdi
testq %rdi, %rdi
je 0x5910f
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq %rcx, %r15
callq 0xa3f0
movq %r15, %rcx
movq -0x60(%rbp), %r15
testl %eax, %eax
jne 0x5910f
movq %rbx, -0x1d(%r13)
orb $0x20, (%r13)
incw 0x40(%rbx)
movq -0x48(%rbp), %rax
orb $0x20, 0xb(%rax)
jmp 0x5910f
movq 0x10(%rdx), %rdx
leaq 0x25f78(%rip), %rsi     # 0x7f0e0
xorl %eax, %eax
callq 0x14804
movq -0x30(%rbp), %rdx
movl $0x1, %r14d
jmp 0x59311
xorl %eax, %eax
movq -0x68(%rbp), %r12
jmp 0x58f20
movq -0x30(%rbp), %rdx
movq %rbx, 0x20(%rdx)
movl $0x1, %r14d
movl -0x38(%rbp), %eax
movq -0x60(%rbp), %r15
jmp 0x59314
cmpw $0x3, 0x40(%rbx)
jb 0x591d7
movq -0x50(%rbp), %rax
movq (%rax), %rdx
movq -0x58(%rbp), %rdi
leaq 0x25e6c(%rip), %rsi     # 0x7f028
xorl %eax, %eax
callq 0x14804
movq -0x30(%rbp), %rdx
movq -0x68(%rbp), %r12
movq -0xa8(%rbp), %r13
jmp 0x59311
leaq 0x25e75(%rip), %rax     # 0x7f053
movq -0x50(%rbp), %rcx
movq %rax, 0x18(%rcx)
movq -0x58(%rbp), %rax
movq 0x280(%rax), %r12
movq -0x40(%rbp), %rcx
movq %rcx, 0x280(%rax)
movq -0x48(%rbp), %rax
movq %rax, %rsi
cmpb $0x1, -0x98(%rbp)
movq -0xa8(%rbp), %r13
ja 0x59217
movq 0x50(%rax), %rsi
movq -0x70(%rbp), %rdi
callq 0x54841
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x280(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, %rax
movq 0x50(%rcx), %rcx
testq %rcx, %rcx
jne 0x59233
movq (%rax), %rax
movq -0x50(%rbp), %rcx
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x5928a
testq %rax, %rax
je 0x5928d
movl (%rax), %ecx
movl (%rsi), %r8d
cmpl %r8d, %ecx
je 0x5928d
movq -0x50(%rbp), %rax
movq (%rax), %rdx
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
leaq 0x25df7(%rip), %rsi     # 0x7f06a
xorl %eax, %eax
callq 0x14804
movq %r12, 0x280(%rbx)
movq -0x68(%rbp), %r12
jmp 0x59409
movq %rax, %rsi
leaq 0x3e(%rbx), %rdx
addq $0x8, %rbx
movq -0x58(%rbp), %rdi
movq %rbx, %rcx
callq 0x59f0f
cmpb $0x1, -0x98(%rbp)
movq -0x70(%rbp), %rdi
ja 0x592d9
movq -0x48(%rbp), %rsi
movzwl 0xa(%rsi), %eax
btl $0xd, %eax
leaq 0x25dcf(%rip), %rax     # 0x7f090
leaq 0x25dea(%rip), %rcx     # 0x7f0b2
cmovaeq %rcx, %rax
movq -0x50(%rbp), %rcx
movq %rax, 0x18(%rcx)
callq 0x54841
movq -0x50(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x58(%rbp), %rax
movq %r12, 0x280(%rax)
movq -0x68(%rbp), %r12
movq -0x30(%rbp), %rdx
cmpq $0x0, 0x20(%rdx)
je 0x59336
movq %r12, %rdi
movq %rdx, %rsi
callq 0x5a45c
movq -0x30(%rbp), %rdx
movl %eax, %r14d
movl -0x38(%rbp), %eax
testl $0xfffffffb, %r14d      # imm = 0xFFFFFFFB
jne 0x58e37
incl %eax
addq $0x70, %rdx
cmpl (%r13), %eax
jl 0x58ef3
jmp 0x59519
cmpq $0x0, 0x10(%rdx)
je 0x593ef
movq %r12, %rdi
xorl %esi, %esi
callq 0x5a1ca
movq -0x30(%rbp), %rdx
movq %rax, 0x20(%rdx)
movl $0x1, %r14d
testq %rax, %rax
je 0x59311
movq %rax, %rbx
movzwl 0x40(%rax), %eax
cmpw $-0x1, %ax
je 0x59415
incl %eax
movw %ax, 0x40(%rbx)
testb $0x10, 0x46(%rbx)
jne 0x59385
testb $0x4, 0x3d(%rdx)
jne 0x594ea
testb $0x10, 0x46(%rbx)
jne 0x59396
cmpq $0x0, 0x18(%rbx)
je 0x592ff
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5a224
movq -0x30(%rbp), %rdx
testl %eax, %eax
movl -0x38(%rbp), %eax
jne 0x59314
movq 0x18(%rbx), %rsi
movq -0x88(%rbp), %rdi
xorl %edx, %edx
callq 0x54d2a
movq -0x30(%rbp), %rcx
movq %rax, 0x28(%rcx)
movzwl 0x3e(%rbx), %r14d
movw $0xffff, 0x3e(%rbx)     # imm = 0xFFFF
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x54841
movq -0x30(%rbp), %rdx
movw %r14w, 0x3e(%rbx)
jmp 0x592ff
movq 0x28(%rdx), %rbx
movq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x54841
movl $0x1, %r14d
testl %eax, %eax
je 0x5943a
movl -0x38(%rbp), %eax
movq -0x30(%rbp), %rdx
jmp 0x59314
movq (%rbx), %rdx
movq %r12, %rdi
leaq 0x25b9a(%rip), %rsi     # 0x7efbc
xorl %eax, %eax
callq 0x14804
movq -0x30(%rbp), %rdx
movq $0x0, 0x20(%rdx)
jmp 0x59311
movl $0x78, %esi
movq -0x88(%rbp), %r15
movq %r15, %rdi
callq 0x144ee
movq %rax, %rcx
testq %rax, %rax
je 0x59508
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rcx)
movups %xmm0, 0x50(%rcx)
movups %xmm0, 0x40(%rcx)
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x20(%rcx)
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
movq $0x0, 0x70(%rcx)
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movw $0x1, 0x40(%rcx)
movq %r15, %rdi
leaq 0x25b17(%rip), %rsi     # 0x7efaf
movq %rcx, %rdx
xorl %eax, %eax
movq %rcx, %r14
callq 0x148c2
movq %r14, %rcx
movq %rax, (%r14)
movq %rbx, %rax
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
jne 0x594ab
movq (%rax), %rsi
leaq 0x3e(%rcx), %rdx
movq %rcx, %rbx
addq $0x8, %rcx
movq %r12, %rdi
callq 0x59f0f
movw $0xffff, 0x3c(%rbx)     # imm = 0xFFFF
movw $0xc8, 0x42(%rbx)
orb $0x2, 0x46(%rbx)
movq -0x60(%rbp), %r15
movq -0x30(%rbp), %rdx
jmp 0x592ff
movq 0x10(%rdx), %rdx
movq %r12, %rdi
leaq 0x25be8(%rip), %rsi     # 0x7f0e0
xorl %eax, %eax
callq 0x14804
movq -0x30(%rbp), %rdx
jmp 0x59311
movq -0x30(%rbp), %rdx
movq %rcx, 0x20(%rdx)
movq -0x60(%rbp), %r15
jmp 0x59311
movq -0x88(%rbp), %rax
cmpb $0x0, 0x51(%rax)
jne 0x58e37
movq 0x28(%r15), %rax
movq %rax, -0x30(%rbp)
cmpl $0x2, (%rax)
jl 0x59881
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %rdx
leaq 0x78(%rax), %r8
leaq 0x30(%r15), %rcx
movq %rcx, -0x58(%rbp)
addq $0x28, %rax
movq %rax, -0x50(%rbp)
xorl %esi, %esi
movq 0x20(%r8), %r14
cmpq $0x0, 0x20(%rdx)
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
movl $0x4, %eax
jne 0x5979f
movzbl 0x3c(%r8), %eax
movl %eax, %edi
andl $0x20, %edi
movl %edi, %ecx
shrl $0x5, %ecx
movq %rcx, -0x38(%rbp)
testb $0x4, %al
movq %r8, -0x40(%rbp)
movq %rsi, -0xa0(%rbp)
movq %r14, -0x48(%rbp)
jne 0x595ea
movl %edi, -0xb0(%rbp)
movq %rdx, -0x80(%rbp)
movq -0x40(%rbp), %r8
movq 0x48(%r8), %rdi
testq %rdi, %rdi
movq -0x68(%rbp), %r12
movq -0xa8(%rbp), %r13
je 0x59663
cmpq $0x0, 0x50(%r8)
je 0x5962a
movq %r12, %rdi
leaq 0x25b84(%rip), %rsi     # 0x7f159
xorl %eax, %eax
callq 0x14804
movq -0x40(%rbp), %r8
movl $0x1, %eax
jmp 0x59762
cmpq $0x0, 0x48(%r8)
jne 0x595fc
cmpq $0x0, 0x50(%r8)
je 0x597d0
movq %rdx, %rbx
movq %r12, %rdi
leaq 0x25b1e(%rip), %rsi     # 0x7f127
xorl %edx, %edx
xorl %eax, %eax
callq 0x14804
movq -0xa0(%rbp), %rsi
movq -0x40(%rbp), %r8
movq %rbx, %rdx
movl $0x1, %eax
jmp 0x5979f
cmpl $0x0, -0xb0(%rbp)
je 0x59640
movl 0x44(%r8), %esi
callq 0x5a5d2
movq -0x40(%rbp), %r8
movq (%r12), %rdi
movq -0x58(%rbp), %rbx
movq (%rbx), %rsi
movq 0x48(%r8), %rdx
callq 0x5a64c
movq -0x40(%rbp), %r8
movq %rax, (%rbx)
movq $0x0, 0x48(%r8)
movq 0x50(%r8), %rbx
xorl %eax, %eax
testq %rbx, %rbx
je 0x59762
cmpl $0x0, 0x8(%rbx)
movq -0xa0(%rbp), %rsi
jle 0x597ca
leal 0x1(%rsi), %eax
movl %eax, -0xc8(%rbp)
leaq 0x1(%rsi), %r12
xorl %r15d, %r15d
movq %rbx, -0xb0(%rbp)
movq (%rbx), %rax
movq %r15, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x5a72b
testl %eax, %eax
js 0x59768
movl %eax, -0x70(%rbp)
movq -0x50(%rbp), %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x5a72b
testl %eax, %eax
jns 0x596ee
incq %r14
addq $0x70, %rbx
cmpq %r14, %r12
jne 0x596c5
movl -0x98(%rbp), %ecx
movl -0x90(%rbp), %edx
jmp 0x596f3
movl %r14d, %edx
movl %eax, %ecx
testl %eax, %eax
movq -0x48(%rbp), %r14
movq -0xb0(%rbp), %rbx
movl %ecx, -0x98(%rbp)
movl %edx, -0x90(%rbp)
js 0x59768
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0xc8(%rbp), %r8d
movl -0x70(%rbp), %r9d
pushq -0x58(%rbp)
pushq -0x38(%rbp)
callq 0x5a53d
addq $0x10, %rsp
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x5969a
movq -0x68(%rbp), %r12
movq -0x60(%rbp), %r15
movq -0xa8(%rbp), %r13
movq -0x80(%rbp), %rdx
movq -0x40(%rbp), %r8
movq -0xa0(%rbp), %rsi
xorl %eax, %eax
jmp 0x5979f
movq -0x80(%rbp), %rdx
jmp 0x59798
movq -0x60(%rbp), %r15
movq -0x68(%rbp), %r12
movq %r12, %rdi
leaq 0x25a16(%rip), %rsi     # 0x7f190
movq %r13, %rdx
xorl %eax, %eax
callq 0x14804
movl $0x1, %eax
movq -0xa8(%rbp), %r13
movq -0x80(%rbp), %rdx
movq -0x40(%rbp), %r8
movq -0xa0(%rbp), %rsi
testb $0x3, %al
jne 0x58e37
incq %rsi
addq $0x70, %r8
addq $0x70, %rdx
movq -0x30(%rbp), %rax
movslq (%rax), %rax
decq %rax
cmpq %rax, %rsi
jl 0x59559
jmp 0x59881
movq -0x80(%rbp), %rdx
jmp 0x5979f
cmpw $0x0, 0x3e(%r14)
movq %rdx, -0x80(%rbp)
movl %edi, -0xb0(%rbp)
jle 0x595a8
leal 0x1(%rsi), %eax
movl %eax, -0x70(%rbp)
leaq 0x1(%rsi), %r12
xorl %r13d, %r13d
movq 0x8(%r14), %rax
leaq (,%r13,2), %rcx
addq %r13, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rbx
movq -0x50(%rbp), %r14
xorl %r15d, %r15d
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x5a72b
testl %eax, %eax
jns 0x5982e
incq %r15
addq $0x70, %r14
cmpq %r15, %r12
jne 0x59811
jmp 0x59838
movl %r15d, -0xc0(%rbp)
movl %eax, -0x74(%rbp)
testl %eax, %eax
movq -0x60(%rbp), %r15
movq -0x48(%rbp), %r14
js 0x5986b
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0xc0(%rbp), %edx
movl -0x74(%rbp), %ecx
movl -0x70(%rbp), %r8d
movl %r13d, %r9d
pushq -0x58(%rbp)
pushq -0x38(%rbp)
callq 0x5a53d
addq $0x10, %rsp
incq %r13
movswq 0x3e(%r14), %rax
cmpq %rax, %r13
jl 0x597f3
jmp 0x595a8
movq -0xb8(%rbp), %rax
movslq (%rax), %rax
testq %rax, %rax
setg %cl
jle 0x59e4f
movq -0xb8(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rax, %rsi
negq %rsi
movl $0x1, %edi
movq (%rdx), %r8
movzbl (%r8), %r9d
cmpl $0x7a, %r9d
je 0x598c5
cmpl $0x9e, %r9d
jne 0x598cf
jmp 0x598ee
movq 0x18(%r8), %r8
cmpb $-0x62, (%r8)
je 0x598ee
cmpq %rax, %rdi
setb %cl
addq $0x20, %rdx
leaq (%rsi,%rdi), %r8
incq %r8
incq %rdi
cmpq $0x1, %r8
jne 0x598ad
jmp 0x59e4f
testb $0x1, %cl
je 0x59e4f
movq -0xb8(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x59e36
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq (%r12), %rax
movl 0x2c(%rax), %eax
andl $0x60, %eax
movl %eax, -0x98(%rbp)
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rbx, -0x80(%rbp)
shlq $0x5, %rbx
movq -0xd0(%rbp), %rax
movq (%rax,%rbx), %rdx
movzbl (%rdx), %eax
cmpl $0x9e, %eax
je 0x599b5
cmpl $0x7a, %eax
jne 0x59967
movq 0x18(%rdx), %rcx
cmpb $-0x62, (%rcx)
jne 0x59967
cmpb $0x7a, %al
jne 0x599b5
movq 0x10(%rdx), %rax
movq 0x8(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x599c0
addq -0xd0(%rbp), %rbx
movq %r12, %rdi
movq %r14, %rsi
callq 0x475f8
movq %rax, %r14
testq %rax, %rax
je 0x599a5
movq 0x8(%rbx), %rax
movq 0x8(%r14), %rcx
movslq (%r14), %rdx
shlq $0x5, %rdx
movq %rax, -0x18(%rcx,%rdx)
movq 0x10(%rbx), %rax
movq %rax, -0x10(%rcx,%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, (%rbx)
movq -0x80(%rbp), %rbx
jmp 0x59e1e
movq $0x0, -0x90(%rbp)
movq -0x80(%rbp), %rbx
cmpl $0x0, (%r13)
jle 0x59deb
movq $0x0, -0xc0(%rbp)
movq $-0x70, -0x30(%rbp)
movl $0x0, -0x74(%rbp)
movq -0xd8(%rbp), %rsi
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rdi
movq %rax, -0x40(%rbp)
testq %rax, %rax
movq %rsi, %r13
jne 0x59a0b
movq (%rdi), %rax
movq %rax, -0x40(%rbp)
movq -0x88(%rbp), %rbx
movb 0x51(%rbx), %al
movb %al, -0xb0(%rbp)
testb %al, %al
movq %r14, -0x48(%rbp)
movq %r13, -0x70(%rbp)
jne 0x59d97
movq 0x28(%r13), %rcx
testq %rcx, %rcx
movq %rdi, -0x38(%rbp)
je 0x59a3e
testb $0x4, 0xb(%rcx)
jne 0x59a91
movq -0x90(%rbp), %r12
testq %r12, %r12
je 0x59a62
movq %r12, %rdi
movq -0x40(%rbp), %rsi
callq 0xa3f0
movq -0x38(%rbp), %rdi
testl %eax, %eax
jne 0x59d97
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0x59a9c
movl 0x28(%rbx), %edx
testl %edx, %edx
jle 0x59aa3
movq 0x20(%rbx), %rsi
addq $0x18, %rsi
xorl %eax, %eax
cmpq %rcx, (%rsi)
je 0x59aa5
incq %rax
addq $0x20, %rsi
cmpq %rax, %rdx
jne 0x59a7c
movl %edx, %eax
jmp 0x59aa5
xorl %eax, %eax
movq -0x90(%rbp), %r12
jmp 0x59ac4
movl $0xfff0bdc0, %eax       # imm = 0xFFF0BDC0
jmp 0x59aa5
xorl %eax, %eax
testl %eax, %eax
js 0x59abb
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq (%rcx,%rax), %rax
xorl %ecx, %ecx
jmp 0x59ac4
xorl %ecx, %ecx
leaq 0x24390(%rip), %rax     # 0x7de54
cmpw $0x0, 0x3e(%rdi)
jle 0x59d97
movq %rax, -0xc8(%rbp)
testq %r12, %r12
sete %al
movq %rcx, %rdx
setne %cl
movq %rdx, -0x58(%rbp)
testq %rdx, %rdx
setne %dl
andb %cl, %dl
movb %dl, -0x50(%rbp)
cmpq $0x0, -0xc0(%rbp)
setne %cl
andb %al, %cl
movb %cl, -0xa0(%rbp)
xorl %r12d, %r12d
movq 0x8(%rdi), %r13
leaq (%r12,%r12,2), %rbx
shlq $0x4, %rbx
movq (%r13,%rbx), %r14
cmpb $0x0, -0x50(%rbp)
je 0x59b51
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %r12, %rcx
shlq $0x5, %rcx
movq 0x10(%rax,%rcx), %rdi
xorl %esi, %esi
movq -0x90(%rbp), %rdx
xorl %ecx, %ecx
callq 0x5820a
movq -0x38(%rbp), %rdi
testl %eax, %eax
je 0x59d86
movq -0x60(%rbp), %rax
cmpw $0x0, 0xa(%rax)
js 0x59b68
testb $0x2, 0x2b(%r13,%rbx)
jne 0x59d86
cmpb $0x0, -0xa0(%rbp)
movq -0xa8(%rbp), %r13
movq -0x60(%rbp), %r15
je 0x59bc6
movq -0x70(%rbp), %rax
testb $0x4, 0x3c(%rax)
je 0x59bae
xorl %ebx, %ebx
movq 0x28(%r13,%rbx), %rdi
movq %r14, %rsi
callq 0x5a72b
testl %eax, %eax
jns 0x59ba6
leaq 0x70(%rbx), %rcx
cmpq %rbx, -0x30(%rbp)
movq %rcx, %rbx
jne 0x59b88
testl %eax, %eax
jns 0x59d7b
movq -0x70(%rbp), %rax
movq 0x50(%rax), %rdi
movq %r14, %rsi
callq 0x5a4e1
testl %eax, %eax
jns 0x59d7b
movq -0x88(%rbp), %rdi
movl $0x1b, %esi
movq %r14, %rdx
callq 0x477b9
movq %rax, %rbx
cmpl $0x20, -0x98(%rbp)
je 0x59bf1
cmpl $0x2, (%r13)
jl 0x59ca9
movq -0x88(%rbp), %r15
movq %r15, %rdi
movl $0x1b, %esi
movq -0x40(%rbp), %rdx
callq 0x477b9
movq -0x68(%rbp), %r13
movq %r13, %rdi
movl $0x7a, %esi
movq %rax, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x43f28
movq %rax, %rbx
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0x59c78
movq %rdi, -0xe8(%rbp)
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0xe0(%rbp)
movq %r15, %rdi
movl $0x1b, %esi
leaq -0xe8(%rbp), %rdx
xorl %ecx, %ecx
callq 0x56afe
movq %r13, %rdi
movl $0x7a, %esi
movq %rax, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x43f28
movq %rax, %rbx
cmpl $0x20, -0x98(%rbp)
movq -0x60(%rbp), %r15
jne 0x59ca9
movq -0x88(%rbp), %rdi
leaq 0x23546(%rip), %rsi     # 0x7d1d9
movq -0x40(%rbp), %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x148c2
movq %rax, %r14
movq %rax, %r13
jmp 0x59cac
xorl %r13d, %r13d
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rbx, %rdx
callq 0x475f8
movq %rax, -0x48(%rbp)
movq %r14, -0xe8(%rbp)
testq %r14, %r14
je 0x59cdb
movq %r14, %rdi
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x59cdd
xorl %eax, %eax
movl %eax, -0xe0(%rbp)
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rbx
movq %rbx, %rsi
leaq -0xe8(%rbp), %rdx
xorl %ecx, %ecx
callq 0x476b0
testq %rbx, %rbx
je 0x59d6c
testb $0x4, 0xb(%r15)
je 0x59d6c
movq -0x48(%rbp), %rax
movslq (%rax), %rbx
shlq $0x5, %rbx
addq 0x8(%rax), %rbx
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x59d41
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %r12, %rcx
shlq $0x5, %rcx
movq 0x10(%rax,%rcx), %rsi
movq -0x88(%rbp), %rdi
callq 0x12d08
jmp 0x59d64
movq -0x88(%rbp), %rdi
leaq 0x2514b(%rip), %rsi     # 0x7ee9a
movq -0xc8(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x148c2
movq %rax, -0x10(%rbx)
orb $0x2, -0x7(%rbx)
movq -0x88(%rbp), %rdi
movq %r13, %rsi
callq 0xb6df
movl $0x1, -0x74(%rbp)
movq -0x38(%rbp), %rdi
incq %r12
movswq 0x3e(%rdi), %rax
cmpq %rax, %r12
jl 0x59b07
cmpb $0x0, -0xb0(%rbp)
movq -0x68(%rbp), %r12
movq -0xa8(%rbp), %r13
movq -0x48(%rbp), %r14
movq -0x70(%rbp), %rsi
jne 0x59dda
movq -0xc0(%rbp), %rdx
incq %rdx
addq $0x70, %rsi
movslq (%r13), %rax
addq $0x70, -0x30(%rbp)
movq %rdx, -0xc0(%rbp)
cmpq %rax, %rdx
jl 0x599f0
cmpl $0x0, -0x74(%rbp)
sete %al
movq -0x80(%rbp), %rbx
movq -0x60(%rbp), %r15
jmp 0x59ded
movb $0x1, %al
testb %al, %al
je 0x59e1e
movq -0x90(%rbp), %rdx
movq %r12, %rdi
testq %rdx, %rdx
je 0x59e10
leaq 0x251dc(%rip), %rsi     # 0x7efe3
xorl %eax, %eax
callq 0x14804
jmp 0x59e1e
leaq 0x251de(%rip), %rsi     # 0x7eff5
xorl %eax, %eax
callq 0x14804
incq %rbx
movq -0xb8(%rbp), %rax
movslq (%rax), %rax
cmpq %rax, %rbx
jl 0x59927
jmp 0x59e39
xorl %r14d, %r14d
movq -0x88(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x3d971
movq %r14, (%r15)
movq (%r15), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x58e3c
movl (%rcx), %ecx
movq -0x88(%rbp), %rdx
cmpl 0x70(%rdx), %ecx
jle 0x58e3c
leaq 0x25193(%rip), %rsi     # 0x7f009
movq %r12, %rdi
xorl %eax, %eax
callq 0x14804
jmp 0x58e37