// File: /workspace/github_c_makefile_star2_O1/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 $0x88, %rsp
movq %rdi, %r12
movq (%rsi), %rdi
movq (%rdi), %rax
movq %rax, -0x58(%rbp)
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpb $0x0, 0x51(%rax)
jne 0x6699b
movq %rsi, %rbx
movq 0x20(%rsi), %rsi
movl %edx, -0x6c(%rbp)
movslq %edx, %rax
imulq $0x38, %rax, %rax
leaq (%rsi,%rax), %rcx
movq %rcx, -0x40(%rbp)
movq %rdi, -0x48(%rbp)
addq $0x54, %rdi
movq %rax, -0x78(%rbp)
movq %rsi, -0x98(%rbp)
movq (%rsi,%rax), %r14
movq 0x10(%r14), %r13
movq %rdi, -0x88(%rbp)
movq %r13, %rsi
callq 0x66ba0
movq %rax, -0x30(%rbp)
movq %r14, -0x38(%rbp)
movzbl (%r14), %r15d
cmpl $0x4c, %r15d
movq %r12, -0x80(%rbp)
je 0x65777
cmpl $0x4b, %r15d
jne 0x6578c
movq -0x38(%rbp), %rax
testb $0x8, 0x5(%rax)
movq 0x20(%rax), %rsi
movq -0x88(%rbp), %r14
movq %r14, %rdi
jne 0x657a5
callq 0x62b04
jmp 0x657aa
movq -0x40(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x88(%rbp), %r14
jmp 0x657b2
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x66ba0
jmp 0x657aa
callq 0x66c34
movq -0x40(%rbp), %rcx
movq %rax, 0x28(%rcx)
movq %r14, %rdi
movq -0x38(%rbp), %r12
movq %r12, %rsi
callq 0x66ba0
testb $0x1, 0x4(%r12)
jne 0x657de
movq $0x0, -0xa0(%rbp)
movq -0x80(%rbp), %r12
movq -0x40(%rbp), %r9
jmp 0x65823
movslq (%r14), %rdi
testq %rdi, %rdi
movq -0x80(%rbp), %r12
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %rsi
jle 0x6580a
movq -0x38(%rbp), %rcx
movswl 0x34(%rcx), %edx
xorl %ecx, %ecx
cmpl %edx, 0x58(%rsi,%rcx,4)
je 0x6580e
incq %rcx
cmpq %rcx, %rdi
jne 0x657fc
xorl %edx, %edx
jmp 0x65816
movl $0x1, %edx
shlq %cl, %rdx
orq %rdx, %rax
decq %rdx
movq %rdx, -0xa0(%rbp)
movq %rax, 0x30(%r9)
movq $-0x1, 0x8(%r9)
movw $0x0, 0x1a(%r9)
leal -0x47(%r15), %edx
cmpl $0xc, %edx
movq %rbx, -0x60(%rbp)
ja 0x65f90
movl $0x1f34, %ecx           # imm = 0x1F34
btl %edx, %ecx
jae 0x65930
testq %r13, %r13
je 0x65887
movq -0x38(%rbp), %rcx
movl 0x4(%r13), %edx
btl $0xc, %edx
jae 0x6588b
btl $0x12, %edx
jb 0x65874
addq $0x10, %r13
jmp 0x6587c
movq 0x20(%r13), %rdx
movq 0x8(%rdx), %r13
movq (%r13), %r13
testq %r13, %r13
jne 0x6585e
jmp 0x6588b
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %r14
testq %r14, %r14
je 0x658b7
movl 0x4(%r14), %ecx
btl $0xc, %ecx
jae 0x658b7
btl $0x12, %ecx
jb 0x658aa
addq $0x10, %r14
jmp 0x658b2
movq 0x20(%r14), %rcx
movq 0x8(%rcx), %r14
movq (%r14), %r14
jmp 0x6588f
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rsi
testq %rsi, 0x28(%r9)
movl $0x1fff, %eax           # imm = 0x1FFF
movl $0x800, %ebx            # imm = 0x800
cmovel %eax, %ebx
leaq -0xb0(%rbp), %rcx
leaq -0x8c(%rbp), %r8
movq %r12, %rdi
movq %r13, %rdx
callq 0x66d3d
movq -0x40(%rbp), %r9
testl %eax, %eax
je 0x65a50
movl -0xb0(%rbp), %eax
movl %eax, 0xc(%r9)
movl -0x8c(%rbp), %eax
movl %eax, 0x10(%r9)
cmpl $0x49, %r15d
je 0x65a35
cmpl $0x4b, %r15d
je 0x65a2f
cmpl $0x4c, %r15d
jne 0x65a3b
movw $0x100, %ax             # imm = 0x100
jmp 0x65a46
testl %edx, %edx
je 0x65b6e
cmpl $0x3, %edx
jne 0x65f90
cmpb $0x48, 0x10(%rbx)
jne 0x65b64
movq -0x38(%rbp), %rbx
movq 0x20(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0x170b8(%rip), %r13     # 0x7ca16
xorl %r12d, %r12d
movzbl (%r13), %r14d
movq 0x10(%rbx), %rsi
movq -0x68(%rbp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq %rax, %r15
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r12), %rsi
movq %rbx, %rdi
movq -0x38(%rbp), %rbx
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq -0x58(%rbp), %rdi
movl %r14d, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x43f28
testq %rax, %rax
je 0x659c4
movl 0x4(%rbx), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%rbx), %ecx
movw %cx, 0x34(%rax)
movq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x65539
movl %eax, %r14d
movq -0x80(%rbp), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x656c7
movq 0x20(%r15), %r9
movslq %r14d, %rax
imulq $0x38, %rax, %rax
movl -0x6c(%rbp), %ecx
movl %ecx, 0x8(%r9,%rax)
movq -0x78(%rbp), %rdx
movzwl 0x18(%r9,%rdx), %ecx
movw %cx, 0x18(%r9,%rax)
incb 0x1e(%r9,%rdx)
addq $0x20, %r12
incq %r13
cmpq $0x20, %r12
je 0x65961
addq -0x78(%rbp), %r9
movq -0x60(%rbp), %rbx
jmp 0x65f90
movw $0x1, %ax
jmp 0x65a46
movw $0x80, %ax
jmp 0x65a46
leal -0x4f(%r15), %ecx
movl $0x2, %eax
shll %cl, %eax
movzwl %bx, %ecx
andl %eax, %ecx
movw %cx, 0x1a(%r9)
cmpl $0x49, %r15d
jne 0x65a5b
orb $0x8, 0x1d(%r9)
movb $0x1, %r13b
testq %r14, %r14
je 0x65acc
movq 0x28(%r9), %rsi
leaq -0xb0(%rbp), %rcx
leaq -0x8c(%rbp), %r8
movq %r12, %rdi
movq %r14, %rdx
movq %r9, %r14
callq 0x66d3d
testl %eax, %eax
je 0x65f80
cmpl $0x0, 0xc(%r14)
js 0x65ad4
movq -0x68(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq %rax, %r13
cmpb $0x0, 0x51(%r14)
je 0x65ae3
movq %r14, %rdi
movq %r13, %rsi
callq 0x3d8f7
xorl %r15d, %r15d
xorl %ecx, %ecx
movq -0x40(%rbp), %r8
movq %r8, %r14
jmp 0x65e9f
movq %r9, %r14
jmp 0x65f80
movq %r14, %r8
xorl %r15d, %r15d
movq -0x38(%rbp), %r13
jmp 0x65ea3
movq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq 0x65539
testl %eax, %eax
je 0x65abb
movq 0x20(%r14), %r14
cltq
imulq $0x38, %rax, %rax
leaq (%r14,%rax), %r12
movl -0x6c(%rbp), %ecx
movl %ecx, 0x8(%r14,%rax)
movq -0x78(%rbp), %rdx
movzwl 0x18(%r14,%rdx), %ecx
movw %cx, 0x18(%r14,%rax)
incb 0x1e(%r14,%rdx)
cmpl $0x49, %r15d
jne 0x65b32
orb $0x8, 0x1d(%r12)
movq -0x78(%rbp), %rax
orb $0x8, 0x1c(%r14,%rax)
addq %rax, %r14
movq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x66e3d
movb $0x1, %cl
testl %eax, %eax
je 0x65e99
orb $0x8, 0x1b(%r14)
movw $0x800, %r15w           # imm = 0x800
jmp 0x65e9c
cmpl $0x47, %r15d
jne 0x65f90
movl $0x1f0, %esi            # imm = 0x1F0
movq -0x68(%rbp), %rdi
callq 0x144ee
movq %rax, %rdi
testq %rax, %rax
je 0x65e80
movl $0x1f0, %edx            # imm = 0x1F0
xorl %esi, %esi
movq %rdi, -0x30(%rbp)
callq 0xa210
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
orb $0x10, 0x1c(%rax)
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movabsq $0x800000000, %rcx      # imm = 0x800000000
movq -0x30(%rbp), %rax
movq %rcx, 0x14(%rax)
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq -0x30(%rbp), %rcx
movq %rax, 0x20(%rcx)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x47, %edx
callq 0x62341
movq -0x30(%rbp), %rsi
movl 0x14(%rsi), %r14d
testl %r14d, %r14d
jle 0x65c1c
incl %r14d
leal -0x2(%r14), %edx
movq %r12, %rdi
callq 0x656c7
movq -0x30(%rbp), %rsi
decl %r14d
cmpl $0x1, %r14d
jg 0x65c03
movq -0x68(%rbp), %rax
cmpb $0x0, 0x51(%rax)
movq -0x48(%rbp), %r11
jne 0x65e88
movl 0x14(%rsi), %ebx
testl %ebx, %ebx
jle 0x66101
movq 0x20(%rsi), %r13
movq $-0x1, -0x50(%rbp)
movq $-0x1, %r12
movq -0x40(%rbp), %r10
movzwl 0x1a(%r13), %eax
testl $0x1ff, %eax            # imm = 0x1FF
je 0x65c9a
movzwl 0x1c(%r13), %edi
testb $0x8, %dil
jne 0x65e5d
movq -0x88(%rbp), %rcx
movslq (%rcx), %rsi
testq %rsi, %rsi
jle 0x65c93
movl 0xc(%r13), %edx
xorl %ecx, %ecx
cmpl %edx, 0x58(%r11,%rcx,4)
je 0x65d6a
incq %rcx
cmpq %rcx, %rsi
jne 0x65c80
xorl %edx, %edx
jmp 0x65d72
movl $0x1e8, %esi            # imm = 0x1E8
movq -0x68(%rbp), %rdi
callq 0x144ee
testq %rax, %rax
je 0x65d55
movq %rax, %r14
movl %ebx, -0x50(%rbp)
movq %r12, %rbx
movq %rax, 0x10(%r13)
orb $0x20, 0x1c(%r13)
movw $0x400, 0x1a(%r13)      # imm = 0x400
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x14(%r14)
movq %r14, %rax
addq $0x28, %rax
movq %rax, 0x20(%r14)
movq (%r13), %rsi
movq %r14, %rdi
movl $0x48, %edx
callq 0x62341
movl 0x14(%r14), %r15d
testl %r15d, %r15d
movq -0x80(%rbp), %r12
jle 0x65d2e
incl %r15d
leal -0x2(%r15), %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x656c7
decl %r15d
cmpl $0x1, %r15d
jg 0x65d16
movq -0x60(%rbp), %rax
movq %rax, 0x8(%r14)
movq -0x68(%rbp), %rax
cmpb $0x0, 0x51(%rax)
movq %rbx, %r12
je 0x65db0
xorl %eax, %eax
movq -0x40(%rbp), %r10
movq -0x48(%rbp), %r11
movl -0x50(%rbp), %ebx
jmp 0x65e52
movq $0x0, -0x50(%rbp)
movq -0x40(%rbp), %r10
movq -0x48(%rbp), %r11
jmp 0x65e5d
movl $0x1, %edx
shlq %cl, %rdx
testb $0x2, %dil
je 0x65e35
testl %esi, %esi
jle 0x65da9
movslq 0x8(%r13), %rcx
imulq $0x38, %rcx, %rcx
movq -0x30(%rbp), %rdi
movq 0x20(%rdi), %rdi
movl 0xc(%rdi,%rcx), %edi
xorl %ecx, %ecx
cmpl %edi, 0x58(%r11,%rcx,4)
je 0x65e2a
incq %rcx
cmpq %rcx, %rsi
jne 0x65d96
xorl %esi, %esi
jmp 0x65e32
movl 0x14(%r14), %edx
testl %edx, %edx
movq -0x40(%rbp), %r10
movq -0x48(%rbp), %r11
movl -0x50(%rbp), %ebx
jle 0x65e50
movq 0x20(%r14), %rsi
xorl %eax, %eax
xorl %edi, %edi
movl $0x7cd, %r14d           # imm = 0x7CD
movq (%rsi), %rcx
movzbl (%rcx), %ecx
addl $-0x49, %ecx
cmpl $0xa, %ecx
ja 0x65e1e
btl %ecx, %r14d
jae 0x65e1e
movq -0x88(%rbp), %rcx
movslq (%rcx), %r8
testq %r8, %r8
jle 0x65e0d
movl 0xc(%rsi), %r9d
xorl %ecx, %ecx
cmpl %r9d, 0x58(%r11,%rcx,4)
je 0x65e12
incq %rcx
cmpq %rcx, %r8
jne 0x65dfe
xorl %r8d, %r8d
jmp 0x65e1b
movl $0x1, %r8d
shlq %cl, %r8
orq %r8, %rax
incl %edi
addq $0x38, %rsi
cmpl %edx, %edi
jne 0x65dd5
jmp 0x65e52
movl $0x1, %esi
shlq %cl, %rsi
orq %rsi, %rdx
andq %rdx, %r12
movq -0x50(%rbp), %rcx
andq %rdx, %rcx
testb $0x2, %al
movl $0x0, %eax
cmoveq %rax, %rcx
movq %rcx, -0x50(%rbp)
jmp 0x65e5d
xorl %eax, %eax
andq %rax, %r12
movq $0x0, -0x50(%rbp)
testq %r12, %r12
setne %al
cmpl $0x2, %ebx
jl 0x66116
decl %ebx
addq $0x38, %r13
testq %r12, %r12
jne 0x65c50
jmp 0x66116
movq -0x40(%rbp), %rax
movq %rdi, 0x10(%rax)
movq -0x60(%rbp), %rbx
movq 0x20(%rbx), %r9
addq -0x78(%rbp), %r9
jmp 0x65f90
xorl %r15d, %r15d
movq %r12, %r8
testb %cl, %cl
je 0x65ee0
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rax
movl 0x4(%rax), %ecx
movl 0x4(%rsi), %edx
xorl %ecx, %edx
btl $0x8, %edx
jb 0x65ef1
btl $0x8, %ecx
jb 0x65ee8
movq -0x58(%rbp), %rdi
movq %r8, %r12
callq 0x529e4
movq %r12, %r8
testq %rax, %rax
je 0x65ef1
movq 0x10(%r13), %rax
orl $0x100, 0x4(%rax)       # imm = 0x100
jmp 0x65ef1
xorl %r13d, %r13d
jmp 0x65f80
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
movl %ecx, 0x4(%rax)
movq 0x18(%r13), %rax
movq 0x10(%r13), %rcx
movq %rcx, 0x18(%r13)
movq %rax, 0x10(%r13)
movb (%r13), %al
cmpb $0x50, %al
jb 0x65f0f
xorb $0x2, %al
movb %al, (%r13)
movl -0xb0(%rbp), %eax
movl %eax, 0xc(%r8)
movl -0x8c(%rbp), %eax
movl %eax, 0x10(%r8)
movq -0x30(%rbp), %rax
orq -0xa0(%rbp), %rax
movq %rax, 0x28(%r8)
movq -0x48(%rbp), %rax
movq %rax, 0x30(%r8)
movzbl (%r13), %ecx
cmpl $0x49, %ecx
je 0x65f5d
cmpl $0x4b, %ecx
movb $0x1, %r13b
je 0x65f57
cmpl $0x4c, %ecx
jne 0x65f66
movw $0x100, %ax             # imm = 0x100
jmp 0x65f70
movw $0x1, %ax
jmp 0x65f70
movw $0x80, %ax
movb $0x1, %r13b
jmp 0x65f70
addb $-0x4f, %cl
movl $0x2, %eax
shll %cl, %eax
movzwl %r15w, %ecx
addl %eax, %ecx
movzwl %bx, %eax
andl %ecx, %eax
movw %ax, 0x1a(%r8)
movq %r14, %r9
testb %r13b, %r13b
movq -0x60(%rbp), %rbx
je 0x6699b
cmpb $0x48, 0x10(%rbx)
jne 0x66875
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movb $0x1, %r13b
movq -0x38(%rbp), %rbx
cmpb $-0x69, (%rbx)
movb $0x1, %r12b
movb $0x1, %dl
jne 0x66057
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x65fef
cmpl $0x2, (%rax)
movb $0x1, %dl
jne 0x66057
movq 0x8(%rbx), %r14
movq %r9, %r12
testq %r14, %r14
je 0x65ff3
movq %rdi, %r15
movq %r14, %rdi
callq 0xa190
movq %r15, %rdi
movq %rax, %rdx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
jmp 0x65ff5
movb $0x1, %dl
jmp 0x66057
xorl %edx, %edx
movq %rdi, %r15
movq %r14, %rsi
movl $0x2, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x19393
testq %rax, %rax
je 0x6604c
movzwl 0x2(%rax), %ecx
movb $0x1, %dl
testb $0x4, %cl
movq %r12, %r9
movb $0x1, %r12b
movq %r15, %rdi
je 0x66057
movq 0x8(%rax), %rax
movb (%rax), %dl
movb %dl, -0x98(%rbp)
movb 0x1(%rax), %dl
movb %dl, -0x50(%rbp)
movb 0x2(%rax), %al
movb %al, -0x30(%rbp)
andl $0x8, %ecx
shrl $0x3, %ecx
xorl %edx, %edx
movl %ecx, %r12d
jmp 0x66057
movb $0x1, %dl
movq %r12, %r9
movb $0x1, %r12b
movq %r15, %rdi
testb %dl, %dl
je 0x66066
xorl %r15d, %r15d
xorl %r14d, %r14d
jmp 0x6660c
movq 0x20(%rbx), %rbx
movq 0x8(%rbx), %rax
movq 0x20(%rax), %r14
cmpb $-0x68, (%r14)
jne 0x660e3
movq %rdi, -0x48(%rbp)
movq %r9, -0x40(%rbp)
movq %r14, %rdi
callq 0x5534e
cmpb $0x42, %al
jne 0x660f2
movq 0x40(%r14), %rax
testb $0x10, 0x46(%rax)
jne 0x660f2
movq 0x8(%rbx), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x66480
movb -0x98(%rbp), %r15b
movb -0x30(%rbp), %r8b
movb -0x50(%rbp), %r9b
movl 0x4(%rbx), %eax
btl $0xc, %eax
jae 0x6648f
btl $0x12, %eax
jb 0x660ce
addq $0x10, %rbx
jmp 0x660d6
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x660b5
jmp 0x6648f
xorl %r15d, %r15d
xorl %r14d, %r14d
movq -0x38(%rbp), %rbx
jmp 0x6660c
xorl %r15d, %r15d
xorl %r14d, %r14d
movq -0x38(%rbp), %rbx
jmp 0x66608
movb $0x1, %al
movq $-0x1, %r12
movq $-0x1, -0x50(%rbp)
movq -0x40(%rbp), %r10
movq -0x30(%rbp), %rdi
movq %r12, 0x1e8(%rdi)
xorl %ecx, %ecx
testq %r12, %r12
setne %cl
shll $0x9, %ecx
movw %cx, 0x1a(%r10)
testb %al, %al
je 0x662e5
cmpl $0x2, 0x14(%rdi)
jne 0x662e5
xorl %edx, %edx
movq 0x20(%rdi), %r13
cmpw $0x400, 0x1a(%r13)      # imm = 0x400
jne 0x66169
movq 0x10(%r13), %rax
movslq 0x14(%rax), %rcx
cmpq %rcx, %rdx
jge 0x66177
imulq $0x38, %rdx, %r13
addq 0x20(%rax), %r13
jmp 0x6617a
testq %rdx, %rdx
movl $0x0, %eax
cmovneq %rax, %r13
jmp 0x6617a
xorl %r13d, %r13d
testq %r13, %r13
je 0x662e5
incq %rdx
movq %rdx, -0x40(%rbp)
xorl %r15d, %r15d
movq 0x20(%rdi), %rax
cmpw $0x400, 0x52(%rax)      # imm = 0x400
jne 0x661b0
movq 0x48(%rax), %rcx
movslq 0x14(%rcx), %rax
cmpq %rax, %r15
jge 0x661c2
imulq $0x38, %r15, %rax
addq 0x20(%rcx), %rax
jmp 0x661c4
addq $0x38, %rax
testq %r15, %r15
movl $0x0, %ecx
cmovneq %rcx, %rax
jmp 0x661c4
xorl %eax, %eax
testq %rax, %rax
je 0x662dc
incq %r15
movzwl 0x1a(%r13), %ecx
testb $0x3e, %cl
je 0x6618d
movzwl 0x1a(%rax), %edx
movl %edx, %esi
andl $0x3e, %esi
je 0x6618d
orl %ecx, %edx
movzwl %dx, %r12d
testl $0xffe5, %r12d          # imm = 0xFFE5
setne %cl
testl $0xffd9, %r12d          # imm = 0xFFD9
setne %dl
testb %dl, %cl
jne 0x6618d
movq (%r13), %r14
movq 0x10(%r14), %rdi
movq (%rax), %rbx
movq 0x10(%rbx), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x544b5
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %r11
testl %eax, %eax
jne 0x6618d
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x544b5
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %r11
testl %eax, %eax
jne 0x6618d
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %r11
testq %rax, %rax
je 0x6618d
leal 0x3f(%r12), %ecx
testb $0x18, %r12b
movl $0x8, %edx
movl $0x20, %esi
cmovel %esi, %edx
testl %r12d, %ecx
cmovnel %edx, %r12d
movzwl %r12w, %edx
xorl %ecx, %ecx
movl $0x2, %esi
shll %cl, %esi
incl %ecx
cmpl %edx, %esi
jne 0x6629b
addb $0x4e, %cl
movb %cl, (%rax)
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x65539
movq -0x80(%rbp), %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x656c7
movq -0x48(%rbp), %r11
movq -0x30(%rbp), %rdi
jmp 0x6618d
movq -0x40(%rbp), %rdx
jmp 0x66145
cmpq $0x0, -0x50(%rbp)
je 0x65e88
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq $0x0, -0x40(%rbp)
movb $0x1, %al
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x20(%rdi), %r15
movl 0x14(%rdi), %ecx
leal -0x1(%rcx), %r13d
testl %ecx, %ecx
jle 0x66369
andb $-0x41, 0x1c(%r15)
movl 0xc(%r15), %edx
cmpl %ebx, %edx
je 0x66353
movq -0x88(%rbp), %rcx
movslq (%rcx), %rsi
testq %rsi, %rsi
jle 0x66341
xorl %ecx, %ecx
cmpl %edx, 0x58(%r11,%rcx,4)
je 0x66345
incq %rcx
cmpq %rcx, %rsi
jne 0x66332
xorl %esi, %esi
jmp 0x6634d
movl $0x1, %esi
shlq %cl, %rsi
testq %rsi, -0x50(%rbp)
jne 0x6636d
addq $0x38, %r15
leal -0x1(%r13), %ecx
testl %r13d, %r13d
movl %ecx, %r13d
jg 0x66314
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movb $0x1, %cl
jmp 0x66375
movl 0x10(%r15), %r12d
xorl %ecx, %ecx
movl %edx, %ebx
testb %cl, %cl
jne 0x66413
testl %r13d, %r13d
js 0x663f6
addq $0x1c, %r15
cmpl %ebx, -0x10(%r15)
jne 0x663d5
xorl %edx, %edx
movl $0x0, %ecx
cmpl %r12d, -0xc(%r15)
jne 0x663e0
movq -0x1c(%r15), %rax
movq 0x18(%rax), %rdi
callq 0x5534e
movl %eax, %r14d
movq -0x1c(%r15), %rax
movq 0x10(%rax), %rdi
callq 0x5534e
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %r11
testb %r14b, %r14b
je 0x663cf
xorl %edx, %edx
movl $0x0, %ecx
cmpb %al, %r14b
jne 0x663e0
orb $0x40, (%r15)
jmp 0x663d9
andb $-0x41, (%r15)
movl $0x1, %ecx
movb $0x1, %dl
testb %dl, %dl
je 0x663fb
leal -0x1(%r13), %eax
addq $0x38, %r15
testl %r13d, %r13d
movl %eax, %r13d
jg 0x66386
jmp 0x663fb
movl $0x1, %ecx
testl %ecx, %ecx
sete %al
movq -0x40(%rbp), %rdx
orl %edx, %ecx
leal 0x1(%rdx), %ecx
movq %rcx, -0x40(%rbp)
je 0x66305
testb $0x1, %al
jne 0x65e88
movl 0x14(%rdi), %r15d
testl %r15d, %r15d
jle 0x669f0
movq 0x20(%rdi), %r12
incl %r15d
xorl %esi, %esi
xorl %r14d, %r14d
testb $0x40, 0x1c(%r12)
je 0x6646e
movq (%r12), %rax
movq 0x18(%rax), %rsi
movq -0x68(%rbp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq -0x48(%rbp), %rcx
movq (%rcx), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x475f8
movq %rax, %r14
movq (%r12), %rax
movq 0x10(%rax), %rsi
addq $0x38, %r12
decl %r15d
cmpl $0x1, %r15d
jg 0x66434
jmp 0x669f5
movb -0x98(%rbp), %r15b
movb -0x30(%rbp), %r8b
movb -0x50(%rbp), %r9b
movb (%rbx), %al
cmpb $-0x79, %al
movb %al, -0x98(%rbp)
jne 0x664dd
movq -0x58(%rbp), %rax
movq 0x210(%rax), %rdi
movswl 0x30(%rbx), %r14d
movl %r14d, %esi
callq 0x66f20
movq %rax, %rdi
testq %rax, %rax
je 0x664e9
movzwl 0x8(%rdi), %eax
andl $0xf, %eax
cmpw $0x2, %ax
jne 0x664e9
movl $0x1, %esi
movq %rdi, %r13
callq 0x11820
movq %r13, %rdi
movq %rax, %rdx
jmp 0x664eb
cmpb $0x61, %al
jne 0x6650e
movq 0x8(%rbx), %rdx
xorl %edi, %edi
jmp 0x66527
xorl %edx, %edx
movb -0x30(%rbp), %r8b
movb -0x50(%rbp), %r9b
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
cmpw $0x21, %r14w
jl 0x66514
movl $0xffffffff, 0x104(%rax) # imm = 0xFFFFFFFF
jmp 0x66527
xorl %edi, %edi
xorl %edx, %edx
jmp 0x66527
decb %r14b
movl $0x1, %esi
movl %r14d, %ecx
shll %cl, %esi
orl %esi, 0x104(%rax)
movb $0x1, %r13b
testq %rdx, %rdx
je 0x665f9
movabsq $-0x200000000, %rax     # imm = 0xFFFFFFFE00000000
xorl %r14d, %r14d
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rsi, %rax
movb (%rdx,%r14), %cl
incq %r14
testb %cl, %cl
je 0x66567
cmpb %r15b, %cl
je 0x66567
cmpb %r9b, %cl
je 0x66567
cmpb %r8b, %cl
jne 0x6654a
cmpq $0x1, %r14
je 0x665f9
sarq $0x20, %rax
cmpb $-0x1, (%rdx,%rax)
je 0x665f9
movq %rdi, -0x50(%rbp)
movl $0x0, -0x30(%rbp)
cmpb %r15b, %cl
jne 0x6659a
movl %r14d, %eax
xorl %ecx, %ecx
cmpb $0x0, (%rdx,%rax)
sete %cl
movl %ecx, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movl $0x61, %esi
callq 0x477b9
movq %rax, %r15
testq %rax, %rax
je 0x665ba
movq 0x8(%r15), %rax
movb $0x0, -0x1(%rax,%r14)
cmpb $-0x79, -0x98(%rbp)
movq -0x50(%rbp), %rdi
jne 0x66aa8
movb %r12b, -0x48(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %r12
movswl 0x30(%rbx), %ecx
cmpl $0x21, %ecx
movl -0x30(%rbp), %r14d
jl 0x66ab8
movl $0xffffffff, 0x104(%r12) # imm = 0xFFFFFFFF
jmp 0x66ac9
xorl %r15d, %r15d
xorl %r14d, %r14d
movq -0x38(%rbp), %rbx
callq 0x1199c
movq -0x40(%rbp), %r9
testb %r13b, %r13b
jne 0x66875
movl %r14d, -0x30(%rbp)
movq %r9, %r14
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %r13
movq -0x68(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq %rax, %rbx
testb %r12b, %r12b
jne 0x666a7
movq -0x58(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x51(%rax)
jne 0x666a7
orb $0x4, 0x1d(%r14)
movq 0x8(%r15), %rax
movb (%rax), %dil
testb %dil, %dil
je 0x666a7
movl $0x1, %ecx
leaq 0x13dd6(%rip), %rdx     # 0x7a440
leaq 0x13c9f(%rip), %rsi     # 0x7a310
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(%rbx), %rdi
movb %al, -0x1(%rdi,%rcx)
movq 0x8(%r15), %rax
movb (%rax,%rcx), %dil
addq %rcx, %rax
incq %rcx
testb %dil, %dil
jne 0x66671
movq -0x68(%rbp), %rax
cmpb $0x0, 0x51(%rax)
je 0x666b6
movl %r12d, %edx
jmp 0x666ff
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x666ce
movq %r14, %rdi
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x666d0
xorl %eax, %eax
movb -0x1(%r14,%rax), %cl
testb %r12b, %r12b
jne 0x666f5
movzbl %cl, %ecx
xorl %edx, %edx
cmpb $0x40, %cl
movl -0x30(%rbp), %esi
cmovel %edx, %esi
movl %esi, -0x30(%rbp)
leaq 0x13c1e(%rip), %rdx     # 0x7a310
movb (%rcx,%rdx), %cl
movl %r12d, %edx
incb %cl
movb %cl, -0x1(%r14,%rax)
leaq 0x1405a(%rip), %rax     # 0x7a760
leaq 0x192fe(%rip), %r12     # 0x7fa0b
testb %dl, %dl
cmovneq %rax, %r12
movq -0x68(%rbp), %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
leaq -0xb0(%rbp), %rdx
movq %r12, (%rdx)
movl $0x6, 0x8(%rdx)
movq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x4b649
movq %r14, %rdi
movl $0x53, %esi
movq %rax, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x43f28
testq %rax, %rax
je 0x66775
movq -0x38(%rbp), %rdx
movl 0x4(%rdx), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x103, %edx            # imm = 0x103
callq 0x65539
movl %eax, %r14d
movq -0x80(%rbp), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x656c7
movq -0x68(%rbp), %rdi
movq %r13, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
leaq -0xb0(%rbp), %rdx
movq %r12, (%rdx)
movl $0x6, 0x8(%rdx)
movq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x4b649
movq %r15, %rdi
movl $0x52, %esi
movq %rax, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x43f28
testq %rax, %rax
je 0x667fc
movq -0x38(%rbp), %rdx
movl 0x4(%rdx), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x103, %edx            # imm = 0x103
callq 0x65539
movl %eax, %r15d
movq -0x80(%rbp), %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x656c7
movq 0x20(%rbx), %rax
movq -0x78(%rbp), %rdi
leaq (%rax,%rdi), %r9
cmpl $0x0, -0x30(%rbp)
movl -0x6c(%rbp), %r8d
je 0x66875
movslq %r14d, %rcx
imulq $0x38, %rcx, %rcx
movl %r8d, 0x8(%rax,%rcx)
movzwl 0x18(%rax,%rdi), %edx
movw %dx, 0x18(%rax,%rcx)
movb 0x1e(%rax,%rdi), %cl
leal 0x1(%rcx), %edx
movb %dl, 0x1e(%rax,%rdi)
movslq %r15d, %rdx
imulq $0x38, %rdx, %rdx
movl %r8d, 0x8(%rax,%rdx)
movzwl 0x18(%rax,%rdi), %esi
movw %si, 0x18(%rax,%rdx)
addb $0x2, %cl
movb %cl, 0x1e(%rax,%rdi)
movb $0x1, %bl
movq -0x38(%rbp), %rax
cmpb $-0x69, (%rax)
jne 0x668a9
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x668a9
cmpl $0x2, (%rax)
jne 0x668a9
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
cmpb $-0x68, (%rax)
jne 0x668a9
movq 0x40(%rax), %rax
testb $0x10, 0x46(%rax)
jne 0x669ad
testb %bl, %bl
jne 0x66990
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %r15
movq 0x20(%rax), %rbx
movq -0x88(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r9, %r12
callq 0x66ba0
movq %rax, %r14
movq %r13, %rdi
movq %rbx, %rsi
callq 0x66ba0
movq %r12, %r9
testq %r14, %rax
movq -0xa0(%rbp), %rax
jne 0x66997
movq -0x68(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq -0x58(%rbp), %rdi
movl $0x33, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x43f28
movq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x65539
movq 0x20(%r15), %rcx
cltq
imulq $0x38, %rax, %rax
movq %r14, 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 -0x30(%rbp), %dl
movb %dl, 0x1f(%rcx,%rax)
movq 0x20(%r15), %rdx
movl -0x6c(%rbp), %esi
movl %esi, 0x8(%rdx,%rax)
movq -0x78(%rbp), %rdi
movzwl 0x18(%rdx,%rdi), %esi
movw %si, 0x18(%rdx,%rax)
incb 0x1e(%rdx,%rdi)
orb $0x8, 0x1c(%rdx,%rdi)
leaq (%rdx,%rdi), %r9
movq 0x30(%rdx,%rdi), %rdx
movq %rdx, 0x30(%rcx,%rax)
movq -0xa0(%rbp), %rax
orq %rax, 0x28(%r9)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r9, %r13
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r14
xorl %r15d, %r15d
leaq 0x2bbbe(%rip), %r12     # 0x92580
movq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0xa3f0
testl %eax, %eax
je 0x669de
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x669c2
jmp 0x669e8
movb 0x8(%r15,%r12), %al
movb %al, -0x30(%rbp)
xorl %ebx, %ebx
movq %r13, %r9
jmp 0x668a9
xorl %r14d, %r14d
xorl %esi, %esi
movq -0x68(%rbp), %r15
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x54a6f
movq -0x58(%rbp), %rdi
movl $0x4b, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43f28
testq %rax, %rax
je 0x66a86
movq -0x38(%rbp), %rdx
movl 0x4(%rdx), %ecx
andl $0x1, %ecx
orl %ecx, 0x4(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq %r14, 0x20(%rax)
movq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x65539
movl %eax, %r14d
movq -0x80(%rbp), %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x656c7
movq 0x20(%r15), %rsi
movslq %r14d, %rax
imulq $0x38, %rax, %rax
movl -0x6c(%rbp), %r15d
movl %r15d, 0x8(%rsi,%rax)
movq -0x78(%rbp), %rdx
movzwl 0x18(%rsi,%rdx), %ecx
movw %cx, 0x18(%rsi,%rax)
incb 0x1e(%rsi,%rdx)
jmp 0x66a9c
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d971
movq -0x78(%rbp), %rdx
movq -0x98(%rbp), %rsi
movw $0x1000, 0x1a(%rsi,%rdx) # imm = 0x1000
jmp 0x65e88
xorl %r13d, %r13d
movq -0x38(%rbp), %rbx
movl -0x30(%rbp), %r14d
jmp 0x66603
decb %cl
movl $0x1, %eax
shll %cl, %eax
orl %eax, 0x104(%r12)
testl %r14d, %r14d
je 0x66af2
movq 0x8(%rbx), %rax
cmpb $0x0, 0x1(%rax)
je 0x66af2
movq -0x58(%rbp), %rdi
movb 0x1f(%rdi), %al
testb %al, %al
je 0x66b02
decb %al
movb %al, 0x1f(%rdi)
movzbl %al, %eax
movl 0x24(%rdi,%rax,4), %r14d
jmp 0x66b0d
xorl %r13d, %r13d
movq -0x38(%rbp), %rbx
movb -0x48(%rbp), %r12b
jmp 0x66603
movl 0x54(%rdi), %r14d
incl %r14d
movl %r14d, 0x54(%rdi)
movq %rbx, %rsi
movl %r14d, %edx
callq 0x511a2
movq (%r12), %rax
cmpb $0x0, 0x51(%rax)
je 0x66b2b
leaq 0x2e9bf(%rip), %rax     # 0x954e8
jmp 0x66b41
movslq 0x3c(%r12), %rax
movq 0x8(%r12), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
addq $-0x18, %rax
movl $0x0, 0xc(%rax)
testl %r14d, %r14d
je 0x66b88
movq -0x58(%rbp), %rdx
movzbl 0x1f(%rdx), %eax
cmpq $0x7, %rax
ja 0x66b88
xorl %ecx, %ecx
cmpl %r14d, 0x94(%rdx,%rcx)
je 0x66b80
addq $0x14, %rcx
cmpl $0xc8, %ecx
jne 0x66b5d
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rdx)
movl %r14d, 0x24(%rdx,%rax,4)
jmp 0x66b88
movb $0x1, 0x8e(%rdx,%rcx)
xorl %r13d, %r13d
movq -0x38(%rbp), %rbx
movb -0x48(%rbp), %r12b
movl -0x30(%rbp), %r14d
movq -0x50(%rbp), %rdi
jmp 0x66603