// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: exprAnalyze
static void exprAnalyze(
  SrcList *pSrc,            /* the FROM clause */
  WhereClause *pWC,         /* the WHERE clause */
  int idxTerm               /* Index of the term to be analyzed */
){
  WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */
  WhereTerm *pTerm;                /* The term to be analyzed */
  WhereMaskSet *pMaskSet;          /* Set of table index masks */
  Expr *pExpr;                     /* The expression to be analyzed */
  Bitmask prereqLeft;              /* Prerequesites of the pExpr->pLeft */
  Bitmask prereqAll;               /* Prerequesites of pExpr */
  Bitmask extraRight = 0;          /* Extra dependencies on LEFT JOIN */
  Expr *pStr1 = 0;                 /* RHS of LIKE/GLOB operator */
  int isComplete = 0;              /* RHS of LIKE/GLOB ends with wildcard */
  int noCase = 0;                  /* uppercase equivalent to lowercase */
  int op;                          /* Top-level operator.  pExpr->op */
  Parse *pParse = pWInfo->pParse;  /* Parsing context */
  sqlite3 *db = pParse->db;        /* Database connection */
  unsigned char eOp2;              /* op2 value for LIKE/REGEXP/GLOB */

  if( db->mallocFailed ){
    return;
  }
  pTerm = &pWC->a[idxTerm];
  pMaskSet = &pWInfo->sMaskSet;
  pExpr = pTerm->pExpr;
  assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
  prereqLeft = sqlite3WhereExprUsage(pMaskSet, pExpr->pLeft);
  op = pExpr->op;
  if( op==TK_IN ){
    assert( pExpr->pRight==0 );
    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
      pTerm->prereqRight = exprSelectUsage(pMaskSet, pExpr->x.pSelect);
    }else{
      pTerm->prereqRight = sqlite3WhereExprListUsage(pMaskSet, pExpr->x.pList);
    }
  }else if( op==TK_ISNULL ){
    pTerm->prereqRight = 0;
  }else{
    pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
  }
  prereqAll = sqlite3WhereExprUsage(pMaskSet, pExpr);
  if( ExprHasProperty(pExpr, EP_FromJoin) ){
    Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable);
    prereqAll |= x;
    extraRight = x-1;  /* ON clause terms may not be used with an index
                       ** on left table of a LEFT JOIN.  Ticket #3015 */
  }
  pTerm->prereqAll = prereqAll;
  pTerm->leftCursor = -1;
  pTerm->iParent = -1;
  pTerm->eOperator = 0;
  if( allowedOp(op) ){
    int iCur, iColumn;
    Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
    Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
    u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;
    if( exprMightBeIndexed(pSrc, prereqLeft, pLeft, &iCur, &iColumn) ){
      pTerm->leftCursor = iCur;
      pTerm->u.leftColumn = iColumn;
      pTerm->eOperator = operatorMask(op) & opMask;
    }
    if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;
    if( pRight 
     && exprMightBeIndexed(pSrc, pTerm->prereqRight, pRight, &iCur, &iColumn)
    ){
      WhereTerm *pNew;
      Expr *pDup;
      u16 eExtraOp = 0;        /* Extra bits for pNew->eOperator */
      if( pTerm->leftCursor>=0 ){
        int idxNew;
        pDup = sqlite3ExprDup(db, pExpr, 0);
        if( db->mallocFailed ){
          sqlite3ExprDelete(db, pDup);
          return;
        }
        idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC);
        if( idxNew==0 ) return;
        pNew = &pWC->a[idxNew];
        markTermAsChild(pWC, idxNew, idxTerm);
        if( op==TK_IS ) pNew->wtFlags |= TERM_IS;
        pTerm = &pWC->a[idxTerm];
        pTerm->wtFlags |= TERM_COPIED;

        if( termIsEquivalence(pParse, pDup) ){
          pTerm->eOperator |= WO_EQUIV;
          eExtraOp = WO_EQUIV;
        }
      }else{
        pDup = pExpr;
        pNew = pTerm;
      }
      exprCommute(pParse, pDup);
      pNew->leftCursor = iCur;
      pNew->u.leftColumn = iColumn;
      testcase( (prereqLeft | extraRight) != prereqLeft );
      pNew->prereqRight = prereqLeft | extraRight;
      pNew->prereqAll = prereqAll;
      pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask;
    }
  }

#ifndef SQLITE_OMIT_BETWEEN_OPTIMIZATION
  /* If a term is the BETWEEN operator, create two new virtual terms
  ** that define the range that the BETWEEN implements.  For example:
  **
  **      a BETWEEN b AND c
  **
  ** is converted into:
  **
  **      (a BETWEEN b AND c) AND (a>=b) AND (a<=c)
  **
  ** The two new terms are added onto the end of the WhereClause object.
  ** The new terms are "dynamic" and are children of the original BETWEEN
  ** term.  That means that if the BETWEEN term is coded, the children are
  ** skipped.  Or, if the children are satisfied by an index, the original
  ** BETWEEN term is skipped.
  */
  else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
    ExprList *pList = pExpr->x.pList;
    int i;
    static const u8 ops[] = {TK_GE, TK_LE};
    assert( pList!=0 );
    assert( pList->nExpr==2 );
    for(i=0; i<2; i++){
      Expr *pNewExpr;
      int idxNew;
      pNewExpr = sqlite3PExpr(pParse, ops[i], 
                             sqlite3ExprDup(db, pExpr->pLeft, 0),
                             sqlite3ExprDup(db, pList->a[i].pExpr, 0), 0);
      transferJoinMarkings(pNewExpr, pExpr);
      idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
      testcase( idxNew==0 );
      exprAnalyze(pSrc, pWC, idxNew);
      pTerm = &pWC->a[idxTerm];
      markTermAsChild(pWC, idxNew, idxTerm);
    }
  }
#endif /* SQLITE_OMIT_BETWEEN_OPTIMIZATION */

#if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY)
  /* Analyze a term that is composed of two or more subterms connected by
  ** an OR operator.
  */
  else if( pExpr->op==TK_OR ){
    assert( pWC->op==TK_AND );
    exprAnalyzeOrTerm(pSrc, pWC, idxTerm);
    pTerm = &pWC->a[idxTerm];
  }
#endif /* SQLITE_OMIT_OR_OPTIMIZATION */

#ifndef SQLITE_OMIT_LIKE_OPTIMIZATION
  /* Add constraints to reduce the search space on a LIKE or GLOB
  ** operator.
  **
  ** A like pattern of the form "x LIKE 'aBc%'" is changed into constraints
  **
  **          x>='ABC' AND x<'abd' AND x LIKE 'aBc%'
  **
  ** The last character of the prefix "abc" is incremented to form the
  ** termination condition "abd".  If case is not significant (the default
  ** for LIKE) then the lower-bound is made all uppercase and the upper-
  ** bound is made all lowercase so that the bounds also work when comparing
  ** BLOBs.
  */
  if( pWC->op==TK_AND 
   && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
  ){
    Expr *pLeft;       /* LHS of LIKE/GLOB operator */
    Expr *pStr2;       /* Copy of pStr1 - RHS of LIKE/GLOB operator */
    Expr *pNewExpr1;
    Expr *pNewExpr2;
    int idxNew1;
    int idxNew2;
    const char *zCollSeqName;     /* Name of collating sequence */
    const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC;

    pLeft = pExpr->x.pList->a[1].pExpr;
    pStr2 = sqlite3ExprDup(db, pStr1, 0);

    /* Convert the lower bound to upper-case and the upper bound to
    ** lower-case (upper-case is less than lower-case in ASCII) so that
    ** the range constraints also work for BLOBs
    */
    if( noCase && !pParse->db->mallocFailed ){
      int i;
      char c;
      pTerm->wtFlags |= TERM_LIKE;
      for(i=0; (c = pStr1->u.zToken[i])!=0; i++){
        pStr1->u.zToken[i] = sqlite3Toupper(c);
        pStr2->u.zToken[i] = sqlite3Tolower(c);
      }
    }

    if( !db->mallocFailed ){
      u8 c, *pC;       /* Last character before the first wildcard */
      pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
      c = *pC;
      if( noCase ){
        /* The point is to increment the last character before the first
        ** wildcard.  But if we increment '@', that will push it into the
        ** alphabetic range where case conversions will mess up the 
        ** inequality.  To avoid this, make sure to also run the full
        ** LIKE on all candidate expressions by clearing the isComplete flag
        */
        if( c=='A'-1 ) isComplete = 0;
        c = sqlite3UpperToLower[c];
      }
      *pC = c + 1;
    }
    zCollSeqName = noCase ? "NOCASE" : "BINARY";
    pNewExpr1 = sqlite3ExprDup(db, pLeft, 0);
    pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
           sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName),
           pStr1, 0);
    transferJoinMarkings(pNewExpr1, pExpr);
    idxNew1 = whereClauseInsert(pWC, pNewExpr1, wtFlags);
    testcase( idxNew1==0 );
    exprAnalyze(pSrc, pWC, idxNew1);
    pNewExpr2 = sqlite3ExprDup(db, pLeft, 0);
    pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
           sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName),
           pStr2, 0);
    transferJoinMarkings(pNewExpr2, pExpr);
    idxNew2 = whereClauseInsert(pWC, pNewExpr2, wtFlags);
    testcase( idxNew2==0 );
    exprAnalyze(pSrc, pWC, idxNew2);
    pTerm = &pWC->a[idxTerm];
    if( isComplete ){
      markTermAsChild(pWC, idxNew1, idxTerm);
      markTermAsChild(pWC, idxNew2, idxTerm);
    }
  }
#endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */

#ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Add a WO_MATCH auxiliary term to the constraint set if the
  ** current expression is of the form:  column MATCH expr.
  ** This information is used by the xBestIndex methods of
  ** virtual tables.  The native query optimizer does not attempt
  ** to do anything with MATCH functions.
  */
  if( isMatchOfColumn(pExpr, &eOp2) ){
    int idxNew;
    Expr *pRight, *pLeft;
    WhereTerm *pNewTerm;
    Bitmask prereqColumn, prereqExpr;

    pRight = pExpr->x.pList->a[0].pExpr;
    pLeft = pExpr->x.pList->a[1].pExpr;
    prereqExpr = sqlite3WhereExprUsage(pMaskSet, pRight);
    prereqColumn = sqlite3WhereExprUsage(pMaskSet, pLeft);
    if( (prereqExpr & prereqColumn)==0 ){
      Expr *pNewExpr;
      pNewExpr = sqlite3PExpr(pParse, TK_MATCH, 
                              0, sqlite3ExprDup(db, pRight, 0), 0);
      idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
      testcase( idxNew==0 );
      pNewTerm = &pWC->a[idxNew];
      pNewTerm->prereqRight = prereqExpr;
      pNewTerm->leftCursor = pLeft->iTable;
      pNewTerm->u.leftColumn = pLeft->iColumn;
      pNewTerm->eOperator = WO_MATCH;
      pNewTerm->eMatchOp = eOp2;
      markTermAsChild(pWC, idxNew, idxTerm);
      pTerm = &pWC->a[idxTerm];
      pTerm->wtFlags |= TERM_COPIED;
      pNewTerm->prereqAll = pTerm->prereqAll;
    }
  }
#endif /* SQLITE_OMIT_VIRTUALTABLE */

#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  /* When sqlite_stat3 histogram data is available an operator of the
  ** form "x IS NOT NULL" can sometimes be evaluated more efficiently
  ** as "x>NULL" if x is not an INTEGER PRIMARY KEY.  So construct a
  ** virtual term of that form.
  **
  ** Note that the virtual term must be tagged with TERM_VNULL.
  */
  if( pExpr->op==TK_NOTNULL
   && pExpr->pLeft->op==TK_COLUMN
   && pExpr->pLeft->iColumn>=0
   && OptimizationEnabled(db, SQLITE_Stat34)
  ){
    Expr *pNewExpr;
    Expr *pLeft = pExpr->pLeft;
    int idxNew;
    WhereTerm *pNewTerm;

    pNewExpr = sqlite3PExpr(pParse, TK_GT,
                            sqlite3ExprDup(db, pLeft, 0),
                            sqlite3PExpr(pParse, TK_NULL, 0, 0, 0), 0);

    idxNew = whereClauseInsert(pWC, pNewExpr,
                              TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL);
    if( idxNew ){
      pNewTerm = &pWC->a[idxNew];
      pNewTerm->prereqRight = 0;
      pNewTerm->leftCursor = pLeft->iTable;
      pNewTerm->u.leftColumn = pLeft->iColumn;
      pNewTerm->eOperator = WO_GT;
      markTermAsChild(pWC, idxNew, idxTerm);
      pTerm = &pWC->a[idxTerm];
      pTerm->wtFlags |= TERM_COPIED;
      pNewTerm->prereqAll = pTerm->prereqAll;
    }
  }
#endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */

  /* Prevent ON clause terms of a LEFT JOIN from being used to drive
  ** an index for tables to the left of the join.
  */
  pTerm->prereqRight |= extraRight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
movq (%rsi), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
cmpb $0x0, 0x51(%rcx)
jne 0x65389
movq %rsi, %r13
movq %rcx, -0x70(%rbp)
movq %rax, -0x58(%rbp)
movq 0x20(%rsi), %rsi
movl %edx, -0x7c(%rbp)
movslq %edx, %rax
imulq $0x38, %rax, %rax
leaq (%rsi,%rax), %rcx
movq %rcx, -0x30(%rbp)
movq %rdi, -0x50(%rbp)
addq $0x54, %rdi
movq %rax, -0x88(%rbp)
movq %rsi, -0xa8(%rbp)
movq (%rsi,%rax), %rbx
movq 0x10(%rbx), %r14
movq %rdi, -0x98(%rbp)
movq %r14, %rsi
callq 0x656e1
movq %rax, -0x68(%rbp)
movq %rbx, -0x48(%rbp)
movzbl (%rbx), %r12d
cmpl $0x4c, %r12d
movq %r15, -0x78(%rbp)
je 0x6426b
cmpl $0x4b, %r12d
jne 0x64288
movq -0x48(%rbp), %rax
testb $0x8, 0x5(%rax)
movq 0x20(%rax), %rsi
movq -0x98(%rbp), %rbx
movq %rbx, %rdi
jne 0x642a1
callq 0x61533
jmp 0x642a6
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
movq $0x0, -0x40(%rbp)
movq -0x98(%rbp), %rbx
jmp 0x642b5
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x98(%rbp), %rbx
movq %rbx, %rdi
callq 0x656e1
jmp 0x642a6
callq 0x65775
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rcx, 0x28(%rax)
movq %rbx, %rdi
movq -0x48(%rbp), %r15
movq %r15, %rsi
callq 0x656e1
movq %rax, %rdi
testb $0x1, 0x4(%r15)
jne 0x642da
xorl %edx, %edx
movq -0x78(%rbp), %r15
movq -0x30(%rbp), %r8
jmp 0x64318
movslq (%rbx), %rax
testq %rax, %rax
movq -0x78(%rbp), %r15
movq -0x30(%rbp), %r8
movq -0x50(%rbp), %rsi
jle 0x64306
movq -0x48(%rbp), %rcx
movswl 0x34(%rcx), %edx
xorl %ecx, %ecx
cmpl %edx, 0x58(%rsi,%rcx,4)
je 0x6430a
incq %rcx
cmpq %rcx, %rax
jne 0x642f8
xorl %edx, %edx
jmp 0x64312
movl $0x1, %edx
shlq %cl, %rdx
orq %rdx, %rdi
decq %rdx
movq %rdi, 0x30(%r8)
movq $-0x1, 0x8(%r8)
movw $0x0, 0x1a(%r8)
leal -0x47(%r12), %eax
cmpl $0xc, %eax
movq %r13, -0x60(%rbp)
movq %rdx, -0x38(%rbp)
ja 0x64ab4
movl $0x1f34, %ecx           # imm = 0x1F34
btl %eax, %ecx
jae 0x64432
testq %r14, %r14
je 0x64377
movl 0x4(%r14), %eax
btl $0xc, %eax
jae 0x6437a
btl $0x12, %eax
jb 0x6436a
addq $0x10, %r14
jmp 0x64372
movq 0x20(%r14), %rax
movq 0x8(%rax), %r14
movq (%r14), %r14
jmp 0x6434f
xorl %r14d, %r14d
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rbx
testq %rbx, %rbx
movq %rdi, -0x90(%rbp)
je 0x643b3
movl 0x4(%rbx), %eax
btl $0xc, %eax
jae 0x643b5
btl $0x12, %eax
jb 0x643a3
addq $0x10, %rbx
jmp 0x643ab
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x6438e
xorl %ebx, %ebx
movq -0x68(%rbp), %rsi
testq %rsi, -0x40(%rbp)
movl $0x1fff, %eax           # imm = 0x1FFF
movl $0x800, %r13d           # imm = 0x800
cmovel %eax, %r13d
leaq -0xc0(%rbp), %rcx
leaq -0x9c(%rbp), %r8
movq %r15, %rdi
movq %r14, %rdx
callq 0x6587e
testl %eax, %eax
je 0x64426
movl -0xc0(%rbp), %eax
movq -0x30(%rbp), %rsi
movl %eax, 0xc(%rsi)
movl -0x9c(%rbp), %ecx
movl %ecx, 0x10(%rsi)
cmpl $0x49, %r12d
je 0x64552
cmpl $0x4b, %r12d
je 0x6454c
cmpl $0x4c, %r12d
jne 0x64558
movw $0x100, %dx             # imm = 0x100
jmp 0x64564
xorl %r14d, %r14d
movq -0x30(%rbp), %rsi
jmp 0x64574
testl %eax, %eax
movq -0x48(%rbp), %r12
je 0x64644
cmpl $0x3, %eax
jne 0x64ab8
cmpb $0x48, 0x10(%r13)
jne 0x64ab8
movq 0x20(%r12), %rax
movq %rax, -0x30(%rbp)
movb $0x1, %r13b
xorl %r15d, %r15d
leaq 0x165ee(%rip), %rax     # 0x7aa56
movzbl (%r15,%rax), %ebx
movq 0x10(%r12), %rsi
movq -0x70(%rbp), %r12
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq %rax, %r14
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x5, %r15
movq (%rax,%r15), %rsi
movq %r12, %rdi
movq -0x48(%rbp), %r12
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq -0x58(%rbp), %rdi
movl %ebx, %esi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x42edf
testq %rax, %rax
je 0x644d3
movl 0x4(%r12), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%r12), %ecx
movw %cx, 0x34(%rax)
movq -0x60(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x64004
movl %eax, %ebx
movq -0x78(%rbp), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x641b8
movq 0x20(%r14), %r8
movslq %ebx, %rax
imulq $0x38, %rax, %rax
movl -0x7c(%rbp), %ecx
movl %ecx, 0x8(%r8,%rax)
movq -0x88(%rbp), %rdx
movzwl 0x18(%r8,%rdx), %ecx
movw %cx, 0x18(%r8,%rax)
incb 0x1e(%r8,%rdx)
movl $0x1, %r15d
testb $0x1, %r13b
movl $0x0, %r13d
jne 0x64461
addq -0x88(%rbp), %r8
movq -0x60(%rbp), %r13
movq -0x38(%rbp), %rdx
jmp 0x64ab8
movw $0x1, %dx
jmp 0x64564
movw $0x80, %dx
jmp 0x64564
leal -0x4f(%r12), %ecx
movl $0x2, %edx
shll %cl, %edx
movzwl %r13w, %ecx
andl %edx, %ecx
movw %cx, 0x1a(%rsi)
testl %eax, %eax
setns %r14b
cmpl $0x49, %r12d
jne 0x6457e
orb $0x8, 0x1d(%rsi)
testq %rbx, %rbx
je 0x645df
leaq -0xc0(%rbp), %rcx
leaq -0x9c(%rbp), %r8
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq %rbx, %rdx
callq 0x6587e
testl %eax, %eax
je 0x645e4
testb %r14b, %r14b
movq -0x30(%rbp), %rdi
je 0x645f1
movq -0x70(%rbp), %r14
movq %r14, %rdi
movq -0x48(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq %rax, %rbx
cmpb $0x0, 0x51(%r14)
je 0x6499c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c8fe
jmp 0x65389
movq %rsi, %r14
jmp 0x645e8
movq -0x30(%rbp), %r14
movq -0x38(%rbp), %rdx
jmp 0x64aad
xorl %r12d, %r12d
movq -0x48(%rbp), %rbx
movq %rdi, %r14
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
movl 0x4(%rax), %ecx
movl 0x4(%rsi), %edx
xorl %ecx, %edx
btl $0x8, %edx
jb 0x64a2d
btl $0x8, %ecx
jb 0x64a24
movq %rdi, %r15
movq -0x58(%rbp), %rdi
callq 0x51845
movq 0x10(%rbx), %rsi
testq %rax, %rax
je 0x64638
orb $0x1, 0x5(%rsi)
movq -0x38(%rbp), %rdx
movq %r15, %rdi
jmp 0x64a31
movl $0x1f0, %esi            # imm = 0x1F0
movq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x145aa
testq %rax, %rax
je 0x64b0d
movl $0x1f0, %edx            # imm = 0x1F0
movq %rax, %rdi
xorl %esi, %esi
movq %rax, -0x40(%rbp)
callq 0xa220
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
orb $0x10, 0x1c(%rax)
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
movq -0x40(%rbp), %rax
movq $0x0, 0x8(%rax)
movabsq $0x800000000, %rcx      # imm = 0x800000000
movq -0x40(%rbp), %rax
movq %rcx, 0x14(%rax)
movq -0x40(%rbp), %rax
addq $0x28, %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x20(%rcx)
movq -0x40(%rbp), %rdi
movq %r12, %rsi
movl $0x47, %edx
callq 0x60d4c
movq -0x40(%rbp), %rsi
movl 0x14(%rsi), %ebx
testl %ebx, %ebx
jle 0x646ee
incl %ebx
leal -0x2(%rbx), %edx
movq %r15, %rdi
callq 0x641b8
movq -0x40(%rbp), %rsi
decl %ebx
cmpl $0x1, %ebx
ja 0x646d8
cmpb $0x0, 0x51(%r14)
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %r11
jne 0x64b1d
movl 0x14(%rsi), %r12d
testl %r12d, %r12d
jle 0x64be5
movq 0x20(%rsi), %r14
movq $-0x1, -0x68(%rbp)
movq $-0x1, %r8
movq -0x30(%rbp), %r10
movzwl 0x1a(%r14), %eax
testl $0x1ff, %eax            # imm = 0x1FF
je 0x64773
movzwl 0x1c(%r14), %edi
testb $0x8, %dil
jne 0x64965
movq -0x98(%rbp), %rcx
movslq (%rcx), %rsi
testq %rsi, %rsi
jle 0x64850
movl 0xc(%r14), %edx
xorl %ecx, %ecx
cmpl %edx, 0x58(%r11,%rcx,4)
je 0x64869
incq %rcx
cmpq %rcx, %rsi
jne 0x64759
xorl %edx, %edx
jmp 0x64871
movq %r8, -0x90(%rbp)
movl $0x1e8, %esi            # imm = 0x1E8
movq -0x70(%rbp), %rdi
callq 0x145aa
testq %rax, %rax
je 0x64830
movq %rax, %rbx
movq %rax, 0x10(%r14)
orb $0x20, 0x1c(%r14)
movw $0x400, 0x1a(%r14)      # imm = 0x400
movq (%r13), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x14(%rbx)
movq %rbx, %rax
addq $0x28, %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x48, %edx
callq 0x60d4c
movq %r15, %r13
movl 0x14(%rbx), %r15d
testl %r15d, %r15d
jle 0x64803
incl %r15d
leal -0x2(%r15), %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x641b8
decl %r15d
cmpl $0x1, %r15d
ja 0x647eb
movq -0x60(%rbp), %rax
movq %rax, 0x8(%rbx)
movq -0x70(%rbp), %rax
cmpb $0x0, 0x51(%rax)
movq -0x50(%rbp), %r11
je 0x648ab
xorl %eax, %eax
movq -0x60(%rbp), %r13
movq -0x78(%rbp), %r15
movq -0x30(%rbp), %r10
jmp 0x6494f
movq $0x0, -0x68(%rbp)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %r10
movq -0x50(%rbp), %r11
movq -0x90(%rbp), %r8
jmp 0x64965
movl $0x0, %edx
movl $0x0, %esi
testb $0x2, %dil
jne 0x6492b
jmp 0x6492e
movl $0x1, %edx
shlq %cl, %rdx
testb $0x2, %dil
je 0x6492e
movq -0x40(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq 0x8(%r14), %rdi
imulq $0x38, %rdi, %rdi
movl 0xc(%rcx,%rdi), %edi
xorl %ecx, %ecx
cmpl %edi, 0x58(%r11,%rcx,4)
je 0x64923
incq %rcx
cmpq %rcx, %rsi
jne 0x64891
xorl %esi, %esi
jmp 0x6492b
movl 0x14(%rbx), %edx
testl %edx, %edx
movq -0x78(%rbp), %r15
movq -0x30(%rbp), %r10
jle 0x64949
movq 0x20(%rbx), %rsi
xorl %eax, %eax
xorl %edi, %edi
movq -0x60(%rbp), %r13
movl $0x7cd, %ebx            # imm = 0x7CD
movq (%rsi), %rcx
movzbl (%rcx), %ecx
addl $-0x49, %ecx
cmpl $0xa, %ecx
ja 0x64917
btl %ecx, %ebx
jae 0x64917
movq -0x98(%rbp), %rcx
movslq (%rcx), %r8
testq %r8, %r8
jle 0x64906
movl 0xc(%rsi), %r9d
xorl %ecx, %ecx
cmpl %r9d, 0x58(%r11,%rcx,4)
je 0x6490b
incq %rcx
cmpq %rcx, %r8
jne 0x648f7
xorl %r8d, %r8d
jmp 0x64914
movl $0x1, %r8d
shlq %cl, %r8
orq %r8, %rax
incl %edi
addq $0x38, %rsi
cmpl %edx, %edi
jne 0x648cf
jmp 0x6494f
movl $0x1, %esi
shlq %cl, %rsi
orq %rsi, %rdx
andq %rdx, %r8
movq -0x68(%rbp), %rcx
andq %rdx, %rcx
testb $0x2, %al
movl $0x0, %eax
cmoveq %rax, %rcx
movq %rcx, -0x68(%rbp)
jmp 0x64961
xorl %eax, %eax
movq -0x60(%rbp), %r13
movq -0x90(%rbp), %r8
andq %rax, %r8
movq $0x0, -0x68(%rbp)
movq -0x38(%rbp), %rdx
cmpl $0x2, %r12d
jl 0x6497b
decl %r12d
addq $0x38, %r14
testq %r8, %r8
jne 0x64725
movq -0x40(%rbp), %rax
movq %r8, 0x1e8(%rax)
testq %r8, %r8
je 0x64dd8
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %rdi
jmp 0x64c03
movq -0x60(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq 0x64004
testl %eax, %eax
je 0x65389
movq 0x20(%r14), %r14
cltq
imulq $0x38, %rax, %rax
leaq (%r14,%rax), %r15
movl -0x7c(%rbp), %ecx
movl %ecx, 0x8(%r14,%rax)
movq -0x88(%rbp), %rdx
movzwl 0x18(%r14,%rdx), %ecx
movw %cx, 0x18(%r14,%rax)
incb 0x1e(%r14,%rdx)
cmpl $0x49, %r12d
jne 0x649f1
orb $0x8, 0x1d(%r15)
movq -0x88(%rbp), %rax
orb $0x8, 0x1c(%r14,%rax)
addq %rax, %r14
movq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x6597e
testl %eax, %eax
je 0x64bda
orb $0x8, 0x1b(%r14)
movw $0x800, %r12w           # imm = 0x800
jmp 0x64bdd
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rdx
movq 0x18(%rbx), %rax
movq %rsi, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movb (%rbx), %al
cmpb $0x50, %al
jb 0x64a47
xorb $0x2, %al
movb %al, (%rbx)
movl -0xc0(%rbp), %eax
movl %eax, 0xc(%rdi)
movl -0x9c(%rbp), %eax
movl %eax, 0x10(%rdi)
movq -0x68(%rbp), %rax
orq %rdx, %rax
movq %rax, 0x28(%rdi)
movq -0x90(%rbp), %rax
movq %rax, 0x30(%rdi)
movzbl (%rbx), %ecx
cmpl $0x49, %ecx
je 0x64a8d
cmpl $0x4b, %ecx
je 0x64a87
cmpl $0x4c, %ecx
jne 0x64a93
movw $0x100, %ax             # imm = 0x100
jmp 0x64a9d
movw $0x1, %ax
jmp 0x64a9d
movw $0x80, %ax
jmp 0x64a9d
addb $-0x4f, %cl
movl $0x2, %eax
shll %cl, %eax
movzwl %r12w, %ecx
addl %eax, %ecx
movzwl %r13w, %eax
andl %ecx, %eax
movw %ax, 0x1a(%rdi)
movq %r14, %r8
movq -0x60(%rbp), %r13
movq -0x48(%rbp), %r12
cmpb $0x48, 0x10(%r13)
jne 0x65226
cmpb $-0x69, (%r12)
jne 0x65385
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x65226
cmpl $0x2, (%rax)
jne 0x65226
movq %r8, -0x30(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %r14
movq 0x8(%r12), %rbx
testq %rbx, %rbx
je 0x64b2a
movq %rbx, %rdi
callq 0xa190
movq %rax, %rdx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
jmp 0x64b2c
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rdx
movq 0x20(%r13), %r8
addq -0x88(%rbp), %r8
jmp 0x64ab8
xorl %edx, %edx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x191e6
testq %rax, %rax
je 0x6521e
movzwl 0x2(%rax), %r13d
testb $0x4, %r13b
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %r8
je 0x65226
movq 0x20(%r12), %r15
movq 0x8(%r15), %rcx
movq 0x20(%rcx), %rbx
cmpb $-0x68, (%rbx)
jne 0x65226
movq 0x8(%rax), %rax
movb (%rax), %cl
movb %cl, -0x50(%rbp)
movb 0x1(%rax), %r12b
movb 0x2(%rax), %al
movb %al, -0x40(%rbp)
movq %rbx, %rdi
callq 0x54166
cmpb $0x42, %al
jne 0x64dc5
movq 0x40(%rbx), %rax
testb $0x10, 0x46(%rax)
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %r8
jne 0x64fcc
movl %r13d, -0x68(%rbp)
movq 0x8(%r15), %rax
movq (%rax), %r13
movl 0x4(%r13), %eax
btl $0xc, %eax
jb 0x65091
movb -0x50(%rbp), %dil
movb -0x40(%rbp), %r8b
jmp 0x650bb
xorl %r12d, %r12d
movq %r15, %rdi
jmp 0x645fb
movq $-0x1, 0x1e8(%rsi)
movq $-0x1, -0x68(%rbp)
movq -0x48(%rbp), %r12
movq %rsi, %rdi
movq -0x30(%rbp), %r10
movw $0x200, 0x1a(%r10)      # imm = 0x200
cmpl $0x2, 0x14(%rdi)
jne 0x64df5
movq 0x20(%rdi), %rax
xorl %esi, %esi
cmpw $0x400, 0x1a(%rax)      # imm = 0x400
jne 0x64c4d
movq 0x10(%rax), %rcx
movslq 0x14(%rcx), %rdx
cmpq %rdx, %rsi
jge 0x64de9
movq 0x20(%rcx), %r12
testq %r12, %r12
movq -0x38(%rbp), %rdx
je 0x64dd2
imulq $0x38, %rsi, %rcx
addq %rcx, %r12
jmp 0x64c59
movq %rax, %r12
testq %rsi, %rsi
jne 0x64dd2
incq %rsi
movq %rsi, -0x30(%rbp)
xorl %r15d, %r15d
cmpw $0x400, 0x52(%rax)      # imm = 0x400
jne 0x64c91
movq 0x48(%rax), %rcx
movslq 0x14(%rcx), %rdx
cmpq %rdx, %r15
jge 0x64db8
movq 0x20(%rcx), %rdx
imulq $0x38, %r15, %rcx
addq %rdx, %rcx
testq %rdx, %rdx
jne 0x64c9e
jmp 0x64db8
leaq 0x38(%rax), %rcx
testq %r15, %r15
jne 0x64db8
movzwl 0x1a(%r12), %eax
testb $0x3e, %al
je 0x64dac
movzwl 0x1a(%rcx), %edx
movl %edx, %esi
andl $0x3e, %esi
je 0x64dac
orl %eax, %edx
movzwl %dx, %r14d
testl $0xffe5, %r14d          # imm = 0xFFE5
setne %al
testl $0xffd9, %r14d          # imm = 0xFFD9
setne %dl
testb %dl, %al
jne 0x64dac
movq (%r12), %rbx
movq 0x10(%rbx), %rdi
movq (%rcx), %r13
movq 0x10(%r13), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x532d3
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %r11
testl %eax, %eax
jne 0x64dac
movq 0x18(%rbx), %rdi
movq 0x18(%r13), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x532d3
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %r11
testl %eax, %eax
jne 0x64dac
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %r11
testq %rax, %rax
je 0x64dac
leal 0x3f(%r14), %ecx
testb $0x18, %r14b
movl $0x8, %edx
movl $0x20, %esi
cmovel %esi, %edx
testl %r14d, %ecx
cmovnel %edx, %r14d
movzwl %r14w, %edx
xorl %ecx, %ecx
movl $0x2, %esi
shll %cl, %esi
incl %ecx
cmpl %edx, %esi
jne 0x64d70
addb $0x4e, %cl
movb %cl, (%rax)
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x64004
movq -0x78(%rbp), %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x641b8
movq -0x50(%rbp), %r11
movq -0x40(%rbp), %rdi
incq %r15
movq 0x20(%rdi), %rax
jmp 0x64c63
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rsi
jmp 0x64c1a
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r12
jmp 0x65222
movq -0x60(%rbp), %r13
jmp 0x64df1
movw $0x0, 0x1a(%r10)
movq -0x48(%rbp), %r12
movq -0x40(%rbp), %rdi
jmp 0x64df5
movq -0x60(%rbp), %r13
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r12
cmpq $0x0, -0x68(%rbp)
je 0x64b1d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %r9d, %r9d
movb $0x1, %r10b
movl 0x14(%rdi), %r14d
testl %r14d, %r14d
jle 0x64f5d
movl %r12d, %eax
movq 0x20(%rdi), %rdx
leaq 0x1c(%rdx), %r15
movq -0x68(%rbp), %r8
andb $-0x41, 0x1c(%rdx)
movl 0xc(%rdx), %r12d
cmpl %eax, %r12d
je 0x64e66
movq -0x98(%rbp), %rcx
movslq (%rcx), %rsi
testq %rsi, %rsi
jle 0x64e55
xorl %ecx, %ecx
cmpl %r12d, 0x58(%r11,%rcx,4)
je 0x64e59
incq %rcx
cmpq %rcx, %rsi
jne 0x64e46
xorl %esi, %esi
jmp 0x64e61
movl $0x1, %esi
shlq %cl, %rsi
testq %r8, %rsi
jne 0x64e80
leal -0x1(%r14), %ecx
addq $0x38, %rdx
addq $0x38, %r15
cmpl $0x1, %r14d
movl %ecx, %r14d
jg 0x64e28
jmp 0x64f55
movq %r9, -0xc8(%rbp)
xorl %ebx, %ebx
testl %r14d, %r14d
jle 0x64f1b
movl 0x10(%rdx), %eax
movl %eax, -0xac(%rbp)
movq -0x38(%rbp), %rdx
cmpl %r12d, -0x10(%r15)
jne 0x64ef9
movl $0x0, -0x90(%rbp)
movb $0x1, %al
movl %eax, -0x30(%rbp)
movl -0xac(%rbp), %eax
cmpl %eax, -0xc(%r15)
jne 0x64f30
movq -0x1c(%r15), %rax
movq 0x18(%rax), %rdi
callq 0x54166
movl %eax, %r13d
movq -0x1c(%r15), %rax
movq 0x10(%rax), %rdi
callq 0x54166
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %r11
movq -0x38(%rbp), %rdx
testb %r13b, %r13b
je 0x64ef3
cmpb %al, %r13b
jne 0x64f30
orb $0x40, (%r15)
jmp 0x64efd
andb $-0x41, (%r15)
incl %ebx
addq $0x38, %r15
cmpl %ebx, %r14d
jne 0x64e9f
movl $0x0, -0x30(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x64f30
movl $0x0, -0x30(%rbp)
movl $0x1, -0x90(%rbp)
movq -0x38(%rbp), %rdx
movq -0xc8(%rbp), %r13
orl %r13d, -0x90(%rbp)
leal 0x1(%r13), %eax
movl %eax, %r9d
movq -0x60(%rbp), %r13
movl -0x30(%rbp), %r10d
je 0x64e0c
jmp 0x64f5d
movq -0x60(%rbp), %r13
movq -0x38(%rbp), %rdx
testb $0x1, %r10b
movq -0x48(%rbp), %r12
jne 0x64b1d
movl -0x7c(%rbp), %r12d
movl 0x14(%rdi), %r14d
testl %r14d, %r14d
jle 0x64fd5
movq 0x20(%rdi), %r15
incl %r14d
xorl %esi, %esi
xorl %ebx, %ebx
testb $0x40, 0x1c(%r15)
je 0x64fbd
movq (%r15), %rax
movq 0x18(%rax), %rsi
movq -0x70(%rbp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq -0x50(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x46675
movq %rax, %rbx
movq (%r15), %rax
movq 0x10(%rax), %rsi
addq $0x38, %r15
decl %r14d
cmpl $0x1, %r14d
ja 0x64f83
jmp 0x64fd9
movq -0x48(%rbp), %r12
jmp 0x65226
xorl %ebx, %ebx
xorl %esi, %esi
movq -0x70(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq -0x58(%rbp), %rdi
movl $0x4b, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x42edf
testq %rax, %rax
je 0x65064
movq -0x48(%rbp), %rdx
movl 0x4(%rdx), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq %rbx, 0x20(%rax)
movq %r13, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x64004
movl %eax, %ebx
movq -0x78(%rbp), %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x641b8
movq 0x20(%r13), %rsi
movslq %ebx, %rax
imulq $0x38, %rax, %rax
movl %r12d, 0x8(%rsi,%rax)
movq -0x88(%rbp), %rdx
movzwl 0x18(%rsi,%rdx), %ecx
movw %cx, 0x18(%rsi,%rax)
incb 0x1e(%rsi,%rdx)
jmp 0x6507d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c97e
movq -0x88(%rbp), %rdx
movq -0xa8(%rbp), %rsi
movw $0x1000, 0x1a(%rsi,%rdx) # imm = 0x1000
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r12
jmp 0x64b1d
movb -0x50(%rbp), %dil
movb -0x40(%rbp), %r8b
btl $0x12, %eax
jb 0x650a5
addq $0x10, %r13
jmp 0x650ad
movq 0x20(%r13), %rax
movq 0x8(%rax), %r13
movq (%r13), %r13
movl 0x4(%r13), %eax
btl $0xc, %eax
jb 0x65099
movb (%r13), %al
cmpb $-0x79, %al
jne 0x65105
movb %al, -0xa8(%rbp)
movq -0x58(%rbp), %rax
movq 0x210(%rax), %rdi
movswl 0x30(%r13), %ebx
movl %ebx, %esi
callq 0x65a61
movq %rax, %r15
testq %rax, %rax
je 0x65118
movzwl 0x8(%r15), %eax
andl $0xf, %eax
cmpw $0x2, %ax
jne 0x65118
movq %r15, %rdi
movl $0x1, %esi
callq 0x118a2
jmp 0x6511a
cmpb $0x61, %al
jne 0x6513c
movb %al, -0xa8(%rbp)
movq 0x8(%r13), %rax
xorl %r15d, %r15d
jmp 0x65155
xorl %eax, %eax
movb -0x50(%rbp), %dil
movb -0x40(%rbp), %r8b
movq -0x58(%rbp), %rcx
movq 0x10(%rcx), %rdx
cmpw $0x21, %bx
jl 0x65144
movl $0xffffffff, 0x104(%rdx) # imm = 0xFFFFFFFF
jmp 0x65155
xorl %r15d, %r15d
jmp 0x65212
decb %bl
movl $0x1, %esi
movl %ebx, %ecx
shll %cl, %esi
orl %esi, 0x104(%rdx)
testq %rax, %rax
je 0x65212
movabsq $-0x200000000, %rcx     # imm = 0xFFFFFFFE00000000
xorl %ebx, %ebx
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rsi, %rcx
movb (%rax,%rbx), %dl
incq %rbx
testb %dl, %dl
je 0x65190
cmpb %dil, %dl
je 0x65190
cmpb %r12b, %dl
je 0x65190
cmpb %r8b, %dl
jne 0x65174
cmpq $0x1, %rbx
movq -0x48(%rbp), %r12
je 0x65216
sarq $0x20, %rcx
cmpb $-0x1, (%rax,%rcx)
je 0x65216
movl $0x0, -0x50(%rbp)
cmpb %dil, %dl
jne 0x651be
movl %ebx, %ecx
xorl %edx, %edx
cmpb $0x0, (%rax,%rcx)
sete %dl
movl %edx, -0x50(%rbp)
movq %r14, %rdi
movl $0x61, %esi
movq %rax, %rdx
callq 0x46837
movq %rax, %r12
testq %rax, %rax
je 0x651e0
movq 0x8(%r12), %rax
movb $0x0, -0x1(%rax,%rbx)
cmpb $-0x79, -0xa8(%rbp)
jne 0x65477
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rbx
movswl 0x30(%r13), %ecx
cmpl $0x21, %ecx
jl 0x6539b
movl $0xffffffff, 0x104(%rbx) # imm = 0xFFFFFFFF
jmp 0x653aa
movq -0x48(%rbp), %r12
movq %r15, %rdi
callq 0x11a2a
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %r8
cmpb $-0x69, (%r12)
jne 0x65385
movq 0x20(%r12), %rax
testq %rax, %rax
je 0x65385
cmpl $0x2, (%rax)
jne 0x65385
movq 0x8(%rax), %rbx
movq 0x20(%rbx), %rcx
cmpb $-0x68, (%rcx)
jne 0x65385
movq 0x40(%rcx), %rax
testb $0x10, 0x46(%rax)
je 0x65385
movq %rcx, -0x48(%rbp)
movq %r8, %r15
movq 0x8(%r12), %r14
xorl %r13d, %r13d
leaq 0x2b303(%rip), %r12     # 0x90580
movq (%r13,%r12), %rsi
movq %r14, %rdi
callq 0xa400
testl %eax, %eax
je 0x652a4
addq $0x10, %r13
cmpq $0x40, %r13
jne 0x6527d
movq -0x38(%rbp), %rdx
movq %r15, %r8
jmp 0x65385
movq (%rbx), %rsi
movq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq %rsi, -0x78(%rbp)
callq 0x656e1
movq %rax, %r14
movq %rbx, %rdi
movq -0x48(%rbp), %rbx
movq %rbx, %rsi
callq 0x656e1
movq %r14, -0x30(%rbp)
testq %r14, %rax
movq -0x38(%rbp), %rdx
movq %r15, %r8
jne 0x65385
movb 0x8(%r13,%r12), %r15b
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq -0x58(%rbp), %rdi
movl $0x33, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x42edf
movq -0x60(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x64004
movq 0x20(%r14), %rcx
cltq
imulq $0x38, %rax, %rax
movq -0x30(%rbp), %rdx
movq %rdx, 0x28(%rcx,%rax)
movl 0x2c(%rbx), %edx
movl %edx, 0xc(%rcx,%rax)
movswl 0x30(%rbx), %edx
movl %edx, 0x10(%rcx,%rax)
movw $0x40, 0x1a(%rcx,%rax)
movb %r15b, 0x1f(%rcx,%rax)
movq 0x20(%r14), %rdx
movl -0x7c(%rbp), %esi
movl %esi, 0x8(%rdx,%rax)
movq -0x88(%rbp), %rdi
movzwl 0x18(%rdx,%rdi), %esi
movw %si, 0x18(%rdx,%rax)
incb 0x1e(%rdx,%rdi)
orb $0x8, 0x1c(%rdx,%rdi)
leaq (%rdx,%rdi), %r8
movq 0x30(%rdx,%rdi), %rdx
movq %rdx, 0x30(%rcx,%rax)
movq -0x38(%rbp), %rdx
orq %rdx, 0x28(%r8)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
decb %cl
movl $0x1, %eax
shll %cl, %eax
orl %eax, 0x104(%rbx)
cmpl $0x0, -0x50(%rbp)
je 0x65477
movq 0x8(%r13), %rax
cmpb $0x0, 0x1(%rax)
je 0x65477
movq -0x58(%rbp), %rax
movb 0x1f(%rax), %al
testb %al, %al
je 0x653e0
decb %al
movq -0x58(%rbp), %rcx
movb %al, 0x1f(%rcx)
movzbl %al, %eax
movl 0x24(%rcx,%rax,4), %r14d
jmp 0x653ef
movq -0x58(%rbp), %rax
movl 0x54(%rax), %r14d
incl %r14d
movl %r14d, 0x54(%rax)
movq -0x58(%rbp), %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x50015
movq (%rbx), %rax
cmpb $0x0, 0x51(%rax)
je 0x65410
leaq 0x2e0ea(%rip), %rax     # 0x934f8
jmp 0x65424
movslq 0x3c(%rbx), %rax
movq 0x8(%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
addq $-0x18, %rax
movl $0x0, 0xc(%rax)
testl %r14d, %r14d
je 0x65477
movq -0x58(%rbp), %rax
movzbl 0x1f(%rax), %eax
cmpq $0x7, %rax
ja 0x65477
xorl %ecx, %ecx
movq -0x58(%rbp), %rdx
cmpl %r14d, 0x94(%rdx,%rcx)
je 0x6546b
addq $0x14, %rcx
cmpl $0xc8, %ecx
jne 0x65444
leal 0x1(%rax), %ecx
movq -0x58(%rbp), %rdx
movb %cl, 0x1f(%rdx)
movl %r14d, 0x24(%rdx,%rax,4)
jmp 0x65477
movq -0x58(%rbp), %rax
movb $0x1, 0x8e(%rax,%rcx)
movq %r15, %rdi
callq 0x11a2a
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %r13
movq -0x70(%rbp), %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
movq %rax, %r14
testb $0x8, -0x68(%rbp)
jne 0x65514
movq -0x58(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x51(%rax)
jne 0x65514
movq -0x30(%rbp), %rax
orb $0x4, 0x1d(%rax)
movq 0x8(%r12), %rax
movb (%rax), %dil
testb %dil, %dil
je 0x65514
movl $0x1, %ecx
leaq 0x12fba(%rip), %rdx     # 0x78490
leaq 0x12e83(%rip), %rsi     # 0x78360
movzbl %dil, %edi
movb (%rdi,%rdx), %r8b
notb %r8b
orb $-0x21, %r8b
movl %edi, %r9d
andb %r8b, %r9b
movb %r9b, (%rax)
movb (%rdi,%rsi), %al
movq 0x8(%r14), %rdi
movb %al, -0x1(%rdi,%rcx)
movq 0x8(%r12), %rax
movb (%rax,%rcx), %dil
addq %rcx, %rax
incq %rcx
testb %dil, %dil
jne 0x654dd
movq -0x70(%rbp), %rax
cmpb $0x0, 0x51(%rax)
jne 0x65565
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x65536
movq %r15, %rdi
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x65538
xorl %eax, %eax
movb -0x1(%r15,%rax), %cl
testb $0x8, -0x68(%rbp)
jne 0x6555e
movzbl %cl, %ecx
xorl %edx, %edx
cmpb $0x40, %cl
movl -0x50(%rbp), %esi
cmovel %edx, %esi
movl %esi, -0x50(%rbp)
leaq 0x12e05(%rip), %rdx     # 0x78360
movb (%rcx,%rdx), %cl
incb %cl
movb %cl, -0x1(%r15,%rax)
testb $0x8, -0x68(%rbp)
leaq 0x184ab(%rip), %rax     # 0x7da1b
leaq 0x13239(%rip), %r15     # 0x787b0
cmoveq %rax, %r15
movq -0x70(%rbp), %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
leaq -0xc0(%rbp), %rdx
movq %r15, (%rdx)
movl $0x6, 0x8(%rdx)
movq -0x58(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x4a5ae
movq %rbx, %rdi
movl $0x53, %esi
movq %rax, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x42edf
testq %rax, %rax
je 0x655dd
movq -0x48(%rbp), %rdx
movl 0x4(%rdx), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
movl $0x103, %edx            # imm = 0x103
callq 0x64004
movl %eax, %ebx
movq -0x78(%rbp), %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x641b8
movq -0x70(%rbp), %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5388d
leaq -0xc0(%rbp), %rdx
movq %r15, (%rdx)
movl $0x6, 0x8(%rdx)
movq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x4a5ae
movq %r15, %rdi
movl $0x52, %esi
movq %rax, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x42edf
testq %rax, %rax
movq -0x48(%rbp), %r12
je 0x65667
movl 0x4(%r12), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%r12), %ecx
movw %cx, 0x34(%rax)
movq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x103, %edx            # imm = 0x103
callq 0x64004
movl %eax, %r14d
movq -0x78(%rbp), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x641b8
movq 0x20(%r15), %rax
movq -0x88(%rbp), %rdi
leaq (%rax,%rdi), %r8
cmpl $0x0, -0x50(%rbp)
movl -0x7c(%rbp), %edx
je 0x656d8
movslq %ebx, %rcx
imulq $0x38, %rcx, %rcx
movl %edx, 0x8(%rax,%rcx)
movl %edx, %r9d
movzwl 0x18(%rax,%rdi), %edx
movw %dx, 0x18(%rax,%rcx)
movb 0x1e(%rax,%rdi), %cl
movslq %r14d, %rsi
imulq $0x38, %rsi, %rsi
movl %r9d, 0x8(%rax,%rsi)
movw %dx, 0x18(%rax,%rsi)
addb $0x2, %cl
movb %cl, 0x1e(%rax,%rdi)
movq -0x38(%rbp), %rdx
jmp 0x65226