// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/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;                  /* LIKE/GLOB distinguishes case */
  int op;                          /* Top-level operator.  pExpr->op */
  Parse *pParse = pWInfo->pParse;  /* Parsing context */
  sqlite3 *db = pParse->db;        /* Database connection */

  if( db->mallocFailed ){
    return;
  }
  pTerm = &pWC->a[idxTerm];
  pMaskSet = &pWInfo->sMaskSet;
  pExpr = pTerm->pExpr;
  assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
  prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
  op = pExpr->op;
  if( op==TK_IN ){
    assert( pExpr->pRight==0 );
    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
      pTerm->prereqRight = exprSelectTableUsage(pMaskSet, pExpr->x.pSelect);
    }else{
      pTerm->prereqRight = exprListTableUsage(pMaskSet, pExpr->x.pList);
    }
  }else if( op==TK_ISNULL ){
    pTerm->prereqRight = 0;
  }else{
    pTerm->prereqRight = exprTableUsage(pMaskSet, pExpr->pRight);
  }
  prereqAll = exprTableUsage(pMaskSet, pExpr);
  if( ExprHasProperty(pExpr, EP_FromJoin) ){
    Bitmask x = getMask(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) ){
    Expr *pLeft = sqlite3ExprSkipCollate(pExpr->pLeft);
    Expr *pRight = sqlite3ExprSkipCollate(pExpr->pRight);
    u16 opMask = (pTerm->prereqRight & prereqLeft)==0 ? WO_ALL : WO_EQUIV;
    if( pLeft->op==TK_COLUMN ){
      pTerm->leftCursor = pLeft->iTable;
      pTerm->u.leftColumn = pLeft->iColumn;
      pTerm->eOperator = operatorMask(op) & opMask;
    }
    if( pRight && pRight->op==TK_COLUMN ){
      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];
        pNew->iParent = idxTerm;
        pTerm = &pWC->a[idxTerm];
        pTerm->nChild = 1;
        pTerm->wtFlags |= TERM_COPIED;
        if( pExpr->op==TK_EQ
         && !ExprHasProperty(pExpr, EP_FromJoin)
         && OptimizationEnabled(db, SQLITE_Transitive)
        ){
          pTerm->eOperator |= WO_EQUIV;
          eExtraOp = WO_EQUIV;
        }
      }else{
        pDup = pExpr;
        pNew = pTerm;
      }
      exprCommute(pParse, pDup);
      pLeft = sqlite3ExprSkipCollate(pDup->pLeft);
      pNew->leftCursor = pLeft->iTable;
      pNew->u.leftColumn = pLeft->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];
      pWC->a[idxNew].iParent = idxTerm;
    }
    pTerm->nChild = 2;
  }
#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( 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;
    Token sCollSeqName;  /* Name of collating sequence */

    pLeft = pExpr->x.pList->a[1].pExpr;
    pStr2 = sqlite3ExprDup(db, pStr1, 0);
    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;
    }
    sCollSeqName.z = noCase ? "NOCASE" : "BINARY";
    sCollSeqName.n = 6;
    pNewExpr1 = sqlite3ExprDup(db, pLeft, 0);
    pNewExpr1 = sqlite3PExpr(pParse, TK_GE, 
           sqlite3ExprAddCollateToken(pParse,pNewExpr1,&sCollSeqName),
           pStr1, 0);
    transferJoinMarkings(pNewExpr1, pExpr);
    idxNew1 = whereClauseInsert(pWC, pNewExpr1, TERM_VIRTUAL|TERM_DYNAMIC);
    testcase( idxNew1==0 );
    exprAnalyze(pSrc, pWC, idxNew1);
    pNewExpr2 = sqlite3ExprDup(db, pLeft, 0);
    pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
           sqlite3ExprAddCollateToken(pParse,pNewExpr2,&sCollSeqName),
           pStr2, 0);
    transferJoinMarkings(pNewExpr2, pExpr);
    idxNew2 = whereClauseInsert(pWC, pNewExpr2, TERM_VIRTUAL|TERM_DYNAMIC);
    testcase( idxNew2==0 );
    exprAnalyze(pSrc, pWC, idxNew2);
    pTerm = &pWC->a[idxTerm];
    if( isComplete ){
      pWC->a[idxNew1].iParent = idxTerm;
      pWC->a[idxNew2].iParent = idxTerm;
      pTerm->nChild = 2;
    }
  }
#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) ){
    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 = exprTableUsage(pMaskSet, pRight);
    prereqColumn = exprTableUsage(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->iParent = idxTerm;
      pTerm = &pWC->a[idxTerm];
      pTerm->nChild = 1;
      pTerm->wtFlags |= TERM_COPIED;
      pNewTerm->prereqAll = pTerm->prereqAll;
    }
  }
#endif /* SQLITE_OMIT_VIRTUALTABLE */

#ifdef SQLITE_ENABLE_STAT3
  /* 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.  This
  ** TERM_VNULL tag will suppress the not-null check at the beginning
  ** of the loop.  Without the TERM_VNULL flag, the not-null check at
  ** the start of the loop will prevent any results from being returned.
  */
  if( pExpr->op==TK_NOTNULL
   && pExpr->pLeft->op==TK_COLUMN
   && pExpr->pLeft->iColumn>=0
   && OptimizationEnabled(db, SQLITE_Stat3)
  ){
    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;
      pNewTerm->iParent = idxTerm;
      pTerm = &pWC->a[idxTerm];
      pTerm->nChild = 1;
      pTerm->wtFlags |= TERM_COPIED;
      pNewTerm->prereqAll = pTerm->prereqAll;
    }
  }
#endif /* SQLITE_ENABLE_STAT */

  /* 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), %rbx
movq (%rbx), %rax
movq (%rax), %rcx
cmpb $0x0, 0x50(%rcx)
jne 0x58c0d
movl %esi, %r12d
movq %rcx, -0x80(%rbp)
movq %rax, -0x70(%rbp)
movq %rdi, -0x48(%rbp)
movq 0x20(%rdi), %rdx
movslq %esi, %rax
imulq $0x38, %rax, %rax
leaq (%rdx,%rax), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x4c(%rbx), %rdi
movq %rax, -0x68(%rbp)
movq %rdx, -0x90(%rbp)
movq (%rdx,%rax), %r14
movq 0x10(%r14), %r15
movq %rdi, -0x40(%rbp)
movq %r15, %rsi
callq 0x58edf
movq %r14, %rsi
movq %rax, -0x50(%rbp)
movzbl (%r14), %r14d
cmpl $0x49, %r14d
movl %r12d, -0x5c(%rbp)
movq %rsi, -0x38(%rbp)
je 0x57d3a
cmpl $0x48, %r14d
jne 0x57d4f
testb $0x8, 0x3(%rsi)
movq 0x20(%rsi), %rsi
movq -0x40(%rbp), %r13
movq %r13, %rdi
jne 0x57d70
callq 0x57007
jmp 0x57d75
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
xorl %r12d, %r12d
movq -0x40(%rbp), %r13
jmp 0x57d84
movq 0x18(%rsi), %rsi
movq -0x40(%rbp), %r13
movq %r13, %rdi
callq 0x58edf
movq -0x38(%rbp), %rsi
movq %rax, %r12
movq -0x30(%rbp), %rax
movq %r12, 0x28(%rax)
jmp 0x57d84
callq 0x58f73
movq %rax, %r12
movq -0x30(%rbp), %rax
movq %r12, 0x28(%rax)
movq -0x38(%rbp), %rsi
movq %r13, %rdi
callq 0x58edf
movq -0x38(%rbp), %r11
testb $0x1, 0x2(%r11)
jne 0x57da7
movq %r13, %rdi
xorl %r13d, %r13d
movq -0x48(%rbp), %r10
movq -0x30(%rbp), %r8
jmp 0x57ded
movslq (%r13), %rsi
testq %rsi, %rsi
movq %r13, %rdi
movq -0x30(%rbp), %r8
jle 0x57dd5
movswl 0x34(%r11), %edx
xorl %r13d, %r13d
xorl %ecx, %ecx
movq -0x48(%rbp), %r10
cmpl %edx, 0x50(%rbx,%rcx,4)
je 0x57dde
incq %rcx
cmpq %rcx, %rsi
jne 0x57dc5
jmp 0x57de7
xorl %r13d, %r13d
movq -0x48(%rbp), %r10
jmp 0x57de7
movl $0x1, %r13d
shlq %cl, %r13
orq %r13, %rax
decq %r13
movq %rax, 0x30(%r8)
movq $-0x1, 0x8(%r8)
movw $0x0, 0x18(%r8)
leal -0x4c(%r14), %ecx
cmpl $0x5, %ecx
setae %sil
movl %r14d, %edx
andl $-0x2, %edx
cmpl $0x48, %edx
setne %dl
testb %sil, %dl
je 0x57f35
cmpl $0x44, %r14d
je 0x57fc1
cmpl $0x47, %r14d
movq -0x68(%rbp), %rbx
jne 0x58520
cmpb $0x45, 0x10(%r10)
jne 0x58520
movq %r13, -0x58(%rbp)
movq 0x20(%r11), %rax
movq %rax, -0x50(%rbp)
movb $0x1, %al
xorl %r13d, %r13d
movq -0x80(%rbp), %rbx
movl %eax, -0x30(%rbp)
leaq 0x20a82(%rip), %rax     # 0x788e4
movzbl (%r13,%rax), %r14d
movq 0x10(%r11), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r11, %r12
callq 0x4848c
movq %rax, %r15
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
movq -0x70(%rbp), %rdi
movl %r14d, %esi
movq %r15, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x3a637
testq %rax, %rax
je 0x57ecb
movzwl 0x2(%r12), %ecx
andl $0x1, %ecx
orw %cx, 0x2(%rax)
movzwl 0x34(%r12), %ecx
movw %cx, 0x34(%rax)
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x57b6d
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x57c97
movq 0x20(%r15), %r8
movslq %r14d, %rax
imulq $0x38, %rax, %rax
movl -0x5c(%rbp), %ecx
movl %ecx, 0x8(%r8,%rax)
movl $0x1, %r13d
testb $0x1, -0x30(%rbp)
movl $0x0, %eax
movq %r12, %r11
jne 0x57e58
movq -0x68(%rbp), %rbx
movb $0x2, 0x1b(%r8,%rbx)
addq %rbx, %r8
movq -0x48(%rbp), %r10
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %r13
jmp 0x58520
testq %r15, %r15
je 0x57f4e
movzbl (%r15), %edx
cmpl $0x5c, %edx
je 0x57f48
cmpl $0x18, %edx
jne 0x57f51
movq 0x10(%r15), %r15
jmp 0x57f35
xorl %r15d, %r15d
movq 0x18(%r11), %r9
testq %r9, %r9
je 0x57f6e
movzbl (%r9), %edx
cmpl $0x5c, %edx
je 0x57f68
cmpl $0x18, %edx
jne 0x57f71
movq 0x10(%r9), %r9
jmp 0x57f55
xorl %r9d, %r9d
testq %r12, -0x50(%rbp)
movl $0xfff, %edx            # imm = 0xFFF
movl $0x400, %ebx            # imm = 0x400
cmovel %edx, %ebx
cmpb $-0x68, (%r15)
jne 0x57fb6
movl 0x2c(%r15), %edx
movl %edx, 0xc(%r8)
movswl 0x30(%r15), %esi
movl %esi, 0x10(%r8)
cmpl $0x48, %r14d
je 0x582fb
cmpl $0x49, %r14d
jne 0x58301
movw $0x80, %si
jmp 0x58308
xorl %ecx, %ecx
movl -0x5c(%rbp), %r14d
jmp 0x5831b
movq -0x80(%rbp), %rdi
movl $0x1f0, %esi            # imm = 0x1F0
callq 0x11721
testq %rax, %rax
je 0x583d9
movq %rax, %r15
movl $0x1f0, %edx            # imm = 0x1F0
movq %rax, %rdi
xorl %esi, %esi
callq 0x8200
movq -0x30(%rbp), %rax
movq %r15, 0x10(%rax)
orb $0x10, 0x1a(%rax)
movq %rbx, (%r15)
movq $0x0, 0x8(%r15)
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x14(%r15)
movq %r15, %rax
addq $0x28, %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
movq -0x38(%rbp), %rsi
movl $0x44, %edx
callq 0x56a32
movl 0x14(%r15), %r14d
testl %r14d, %r14d
jle 0x5804c
incl %r14d
leal -0x2(%r14), %esi
movq %r15, %rdi
callq 0x57c97
decl %r14d
cmpl $0x1, %r14d
ja 0x58037
movq %r15, -0x88(%rbp)
movq -0x80(%rbp), %rax
cmpb $0x0, 0x50(%rax)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r11
movq -0x48(%rbp), %r10
jne 0x583f1
movq -0x88(%rbp), %rax
movl 0x14(%rax), %r12d
testl %r12d, %r12d
movq %r13, -0x58(%rbp)
jle 0x58680
movq 0x20(%rax), %r14
movq $-0x1, %r15
movq $-0x1, %r9
movzbl 0x18(%r14), %eax
testw %ax, %ax
je 0x580da
movb 0x1a(%r14), %r8b
testb $0x8, %r8b
jne 0x582b2
movslq (%rdi), %rsi
testq %rsi, %rsi
jle 0x581a5
movl 0xc(%r14), %edx
xorl %ecx, %ecx
cmpl %edx, 0x50(%rbx,%rcx,4)
je 0x581be
incq %rcx
cmpq %rcx, %rsi
jne 0x580c1
xorl %edx, %edx
jmp 0x581c6
movq %r9, -0x50(%rbp)
movq -0x80(%rbp), %rdi
movl $0x1e8, %esi            # imm = 0x1E8
callq 0x11721
testq %rax, %rax
je 0x5818d
movq %rax, %r15
movq %rax, 0x10(%r14)
orb $0x20, 0x1a(%r14)
movw $0x200, 0x18(%r14)      # imm = 0x200
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x14(%r15)
movq %r15, %rax
addq $0x28, %rax
movq %rax, 0x20(%r15)
movq (%r14), %rsi
movq %r15, %rdi
movl $0x45, %edx
callq 0x56a32
movl 0x14(%r15), %r13d
testl %r13d, %r13d
jle 0x58164
incl %r13d
leal -0x2(%r13), %esi
movq %r15, %rdi
callq 0x57c97
decl %r13d
cmpl $0x1, %r13d
ja 0x5814f
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%r15)
movq -0x80(%rbp), %rax
cmpb $0x0, 0x50(%rax)
je 0x58204
xorl %eax, %eax
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %r13
movq -0x38(%rbp), %r11
jmp 0x582a4
xorl %r15d, %r15d
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r11
movq -0x48(%rbp), %r10
movq -0x50(%rbp), %r9
jmp 0x582b2
movl $0x0, %edx
movl $0x0, %esi
testb $0x2, %r8b
jne 0x58289
jmp 0x5828c
movl $0x1, %edx
shlq %cl, %rdx
testb $0x2, %r8b
je 0x5828c
movq -0x88(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq 0x8(%r14), %r8
imulq $0x38, %r8, %r8
movl 0xc(%rcx,%r8), %r8d
xorl %ecx, %ecx
cmpl %r8d, 0x50(%rbx,%rcx,4)
je 0x58281
incq %rcx
cmpq %rcx, %rsi
jne 0x581ea
xorl %esi, %esi
jmp 0x58289
movl 0x14(%r15), %edx
testl %edx, %edx
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %r13
movq -0x38(%rbp), %r11
jle 0x582a2
movq 0x20(%r15), %rsi
xorl %eax, %eax
xorl %r10d, %r10d
movq (%rsi), %rcx
movzbl (%rcx), %ecx
leal -0x51(%rcx), %r8d
cmpl $-0x5, %r8d
setb %r8b
andl $-0x2, %ecx
cmpl $0x48, %ecx
setne %cl
testb %r8b, %cl
jne 0x58273
movslq (%rdi), %r8
testq %r8, %r8
jle 0x58262
movl 0xc(%rsi), %r9d
xorl %ecx, %ecx
cmpl %r9d, 0x50(%rbx,%rcx,4)
je 0x58267
incq %rcx
cmpq %rcx, %r8
jne 0x58253
xorl %r8d, %r8d
jmp 0x58270
movl $0x1, %r8d
shlq %cl, %r8
orq %r8, %rax
incl %r10d
addq $0x38, %rsi
cmpl %edx, %r10d
jne 0x58225
jmp 0x582a4
movl $0x1, %esi
shlq %cl, %rsi
orq %rsi, %rdx
andq %rdx, %r9
movzwl %ax, %eax
andq %rdx, %r15
testb $0x2, %al
movl $0x0, %eax
cmoveq %rax, %r15
jmp 0x582b2
xorl %eax, %eax
movq -0x50(%rbp), %r9
andq %rax, %r9
xorl %r15d, %r15d
movq -0x48(%rbp), %r10
cmpl $0x2, %r12d
jl 0x582c8
decl %r12d
addq $0x38, %r14
testq %r9, %r9
jne 0x58097
movq -0x88(%rbp), %rax
movq %r9, 0x1e8(%rax)
xorl %eax, %eax
testq %r9, %r9
setne %al
shll $0x8, %eax
movq -0x30(%rbp), %rcx
movw %ax, 0x18(%rcx)
movq %r15, -0x30(%rbp)
testq %r15, %r15
jne 0x5869d
jmp 0x583f1
movw $0x1, %si
jmp 0x58308
movl $0x2, %esi
shll %cl, %esi
movl -0x5c(%rbp), %r14d
movzwl %bx, %ecx
andl %esi, %ecx
movw %cx, 0x18(%r8)
testl %edx, %edx
setns %cl
testq %r9, %r9
je 0x5851c
cmpb $-0x68, (%r9)
jne 0x5851c
movq %rax, -0x90(%rbp)
testb %cl, %cl
je 0x58377
movq -0x80(%rbp), %r12
movq %r12, %rdi
movq %r11, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
movq %rax, %r15
cmpb $0x0, 0x50(%r12)
je 0x58401
movq %r12, %rdi
movq %r15, %rsi
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3479d
xorl %r12d, %r12d
movq %r11, %r15
movq %r8, %r14
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rax
movzwl 0x2(%rax), %ecx
movl $0x100, %r9d            # imm = 0x100
movl %ecx, %edx
andl %r9d, %edx
movzwl 0x2(%rsi), %r8d
andl %r9d, %r8d
cmpw %r8w, %dx
jne 0x5848c
testw %dx, %dx
jne 0x58482
movq -0x70(%rbp), %rdi
callq 0x4b225
movq 0x10(%r15), %rsi
testq %rax, %rax
je 0x583c8
orb $0x1, 0x3(%rsi)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r11
movq -0x48(%rbp), %r10
jmp 0x5848c
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r11
movq -0x48(%rbp), %r10
movq 0x20(%r10), %r8
movq -0x68(%rbp), %rbx
addq %rbx, %r8
jmp 0x58520
movq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq 0x57b6d
testl %eax, %eax
je 0x58c0d
movq %r12, %r10
movq 0x20(%r12), %rcx
cltq
imulq $0x38, %rax, %rax
movl %r14d, 0x8(%rcx,%rax)
movq -0x68(%rbp), %rdx
movb $0x1, 0x1b(%rcx,%rdx)
orb $0x8, 0x1a(%rcx,%rdx)
leaq (%rcx,%rax), %r14
addq %rdx, %rcx
movq -0x38(%rbp), %r11
cmpb $0x4c, (%r11)
movq %rcx, -0x30(%rbp)
jne 0x5888b
testb $0x1, 0x2(%r11)
movq -0x40(%rbp), %rdi
jne 0x58897
movq -0x80(%rbp), %rax
testb $0x2, 0x4d(%rax)
jne 0x58897
orb $0x4, 0x19(%rcx)
movw $0x400, %r12w           # imm = 0x400
jmp 0x58380
andl $0xfeff, %ecx           # imm = 0xFEFF
movw %cx, 0x2(%rax)
movq -0x30(%rbp), %r8
movq -0x90(%rbp), %rdx
movq 0x18(%r15), %rax
movq %rsi, 0x18(%r15)
movq %rax, 0x10(%r15)
movb (%r15), %cl
cmpb $0x4d, %cl
jb 0x584bd
addb $-0x4d, %cl
xorb $0x2, %cl
addb $0x4d, %cl
movb %cl, (%r15)
jmp 0x584bd
movq 0x10(%rax), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x584b9
cmpl $0x18, %ecx
je 0x584b9
movl 0x2c(%rax), %ecx
movl %ecx, 0xc(%r14)
movswl 0x30(%rax), %eax
movl %eax, 0x10(%r14)
movq -0x50(%rbp), %rax
orq %r13, %rax
movq %rax, 0x28(%r14)
movq %rdx, 0x30(%r14)
movzbl (%r15), %ecx
cmpl $0x48, %ecx
je 0x584fc
cmpl $0x49, %ecx
jne 0x58502
movw $0x80, %ax
jmp 0x5850c
movw $0x1, %ax
jmp 0x5850c
addb $-0x4c, %cl
movl $0x2, %eax
shll %cl, %eax
movzwl %r12w, %ecx
addl %eax, %ecx
movzwl %bx, %eax
andl %ecx, %eax
movw %ax, 0x18(%r14)
movq -0x68(%rbp), %rbx
cmpb $0x45, 0x10(%r10)
jne 0x58ac1
cmpb $-0x69, (%r11)
jne 0x58c09
movq 0x20(%r11), %rax
testq %rax, %rax
je 0x58ac1
cmpl $0x2, (%rax)
jne 0x58ac1
movq -0x70(%rbp), %rax
movq (%rax), %r14
movq 0x8(%r11), %rsi
testq %rsi, %rsi
movq %r8, %r12
je 0x58579
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rsi, %rax
incl %edx
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x58566
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
jmp 0x5857b
xorl %edx, %edx
movq %r14, %rdi
movl $0x2, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x15493
testq %rax, %rax
je 0x58ab6
movb 0x3(%rax), %dl
testb $0x1, %dl
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r11
movq %r12, %r8
je 0x58ac1
movq %r13, -0x58(%rbp)
movq 0x20(%r11), %rcx
movq 0x8(%rcx), %r13
movq 0x20(%r13), %r15
cmpb $-0x68, (%r15)
jne 0x58882
movb %dl, -0x90(%rbp)
movq 0x8(%rax), %rax
movb (%rax), %cl
movb %cl, -0x30(%rbp)
movb 0x1(%rax), %cl
movb %cl, -0x50(%rbp)
movb 0x2(%rax), %bl
movq %r15, %rdi
callq 0x4b192
cmpb $0x61, %al
jne 0x5889f
movq 0x40(%r15), %rax
testb $0x10, 0x46(%rax)
movq -0x40(%rbp), %rdi
jne 0x5896a
movq (%r13), %r9
movb (%r9), %al
cmpb $-0x7c, %al
jne 0x58614
movb 0x37(%r9), %al
cmpb $-0x7b, %al
jne 0x5897e
movb %al, -0x74(%rbp)
movq -0x70(%rbp), %rax
movq 0x220(%rax), %rdi
movq %r9, -0x88(%rbp)
movswl 0x30(%r9), %r15d
movl %r15d, %esi
callq 0x59084
movq %rax, %rdi
testq %rax, %rax
movq -0x58(%rbp), %r13
je 0x58999
cmpb $0x3, 0x26(%rdi)
jne 0x58999
movq %rdi, -0x98(%rbp)
movq -0x98(%rbp), %rdi
movl $0x1, %esi
callq 0xef29
movq -0x98(%rbp), %rdi
movq -0x58(%rbp), %r13
jmp 0x5899b
movq $-0x1, 0x1e8(%rax)
movq -0x30(%rbp), %rax
movw $0x100, 0x18(%rax)      # imm = 0x100
movq $-0x1, -0x30(%rbp)
movq -0x88(%rbp), %rax
movq 0x20(%rax), %rcx
movl 0x14(%rax), %r8d
movq %rcx, -0xa8(%rbp)
leaq 0x1a(%rcx), %r9
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movb $0x1, %al
movl %eax, -0x74(%rbp)
testl %r8d, %r8d
jle 0x583f1
movl %r15d, %eax
movq %r9, %r14
movl %r8d, %r13d
movq -0xa8(%rbp), %rdx
andb $-0x41, 0x1a(%rdx)
movl 0xc(%rdx), %r15d
cmpl %eax, %r15d
je 0x58716
movslq (%rdi), %rsi
testq %rsi, %rsi
jle 0x58704
xorl %ecx, %ecx
cmpl %r15d, 0x50(%rbx,%rcx,4)
je 0x58708
incq %rcx
cmpq %rcx, %rsi
jne 0x586f5
xorl %esi, %esi
jmp 0x58710
movl $0x1, %esi
shlq %cl, %rsi
testq %rsi, -0x30(%rbp)
jne 0x58730
leal -0x1(%r13), %ecx
addq $0x38, %rdx
addq $0x38, %r14
cmpl $0x1, %r13d
movl %ecx, %r13d
jg 0x586de
jmp 0x5880d
movq %r12, -0xb0(%rbp)
movq %r9, -0xb8(%rbp)
xorl %r12d, %r12d
testl %r13d, %r13d
jle 0x587d2
movl 0x10(%rdx), %eax
movl %eax, -0xa0(%rbp)
movl %r8d, -0x9c(%rbp)
cmpl %r15d, -0xe(%r14)
jne 0x587c2
movl $0x0, -0x98(%rbp)
movb $0x1, %al
movl %eax, -0x74(%rbp)
movl -0xa0(%rbp), %eax
cmpl %eax, -0xa(%r14)
jne 0x587e3
movq -0x1a(%r14), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%rax), %rdi
callq 0x4b192
movb %al, -0x88(%rbp)
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4b192
movb -0x88(%rbp), %cl
movl -0x9c(%rbp), %r8d
movq -0x38(%rbp), %r11
movq -0x40(%rbp), %rdi
testb %cl, %cl
je 0x587bc
cmpb %al, %cl
jne 0x587e3
orb $0x40, (%r14)
jmp 0x587c6
andb $-0x41, (%r14)
incl %r12d
addq $0x38, %r14
cmpl %r12d, %r13d
jne 0x5875a
movl $0x0, -0x74(%rbp)
movl $0x1, -0x98(%rbp)
movq -0xb0(%rbp), %rax
orl %eax, -0x98(%rbp)
leal 0x1(%rax), %eax
movl %eax, %r12d
movq -0x48(%rbp), %r10
movq -0x58(%rbp), %r13
movq -0xb8(%rbp), %r9
je 0x586c5
jmp 0x58815
movq -0x48(%rbp), %r10
movq -0x58(%rbp), %r13
testb $0x1, -0x74(%rbp)
jne 0x583f1
testl %r8d, %r8d
jle 0x588b0
incl %r8d
xorl %esi, %esi
xorl %r14d, %r14d
movq -0xa8(%rbp), %r15
testb $0x40, 0x1a(%r15)
je 0x58873
movq (%r15), %rax
movq 0x18(%rax), %rsi
movq -0x80(%rbp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl %r8d, %r12d
callq 0x4848c
movq (%rbx), %rcx
movq (%rcx), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3d962
movl %r12d, %r8d
movq %rax, %r14
movq (%r15), %rax
movq 0x10(%rax), %rsi
addq $0x38, %r15
decl %r8d
cmpl $0x1, %r8d
ja 0x58837
jmp 0x588b5
movq -0x58(%rbp), %r13
jmp 0x58ac1
xorl %r12d, %r12d
movq -0x40(%rbp), %rdi
jmp 0x58380
xorl %r12d, %r12d
jmp 0x58380
movq -0x68(%rbp), %rbx
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %r13
jmp 0x58aba
xorl %r14d, %r14d
xorl %esi, %esi
movq -0x80(%rbp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
movq -0x70(%rbp), %rdi
movl $0x48, %esi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3a637
testq %rax, %rax
je 0x5893c
movq -0x38(%rbp), %rdx
movzwl 0x2(%rdx), %ecx
andl $0x1, %ecx
orw %cx, 0x2(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq %r14, 0x20(%rax)
movq -0x48(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x57b6d
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x57c97
movq %rbx, %r10
movq 0x20(%rbx), %rcx
movslq %r14d, %rax
imulq $0x38, %rax, %rax
movl -0x5c(%rbp), %edx
movl %edx, 0x8(%rcx,%rax)
movq -0x68(%rbp), %rax
movb $0x1, 0x1b(%rcx,%rax)
jmp 0x58956
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3484e
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %r10
movq -0x90(%rbp), %rcx
movw $0x800, 0x18(%rcx,%rax) # imm = 0x800
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r11
jmp 0x583f1
movq %r12, %r8
movq -0x68(%rbp), %rbx
movq -0x58(%rbp), %r13
movq -0x38(%rbp), %r11
jmp 0x58ac1
cmpb $0x5e, %al
movq -0x58(%rbp), %r13
movb -0x30(%rbp), %r10b
movb -0x50(%rbp), %r11b
jne 0x589c5
movb %al, -0x74(%rbp)
movq 0x8(%r9), %rax
xorl %edi, %edi
jmp 0x589df
xorl %eax, %eax
movq -0x88(%rbp), %r9
movb -0x30(%rbp), %r10b
movb -0x50(%rbp), %r11b
movq -0x70(%rbp), %rcx
movq 0x10(%rcx), %rdx
cmpw $0x21, %r15w
jl 0x589cc
movl $0xffffffff, 0x104(%rdx) # imm = 0xFFFFFFFF
jmp 0x589df
xorl %edi, %edi
jmp 0x58aad
decb %r15b
movl $0x1, %esi
movl %r15d, %ecx
shll %cl, %esi
orl %esi, 0x104(%rdx)
testq %rax, %rax
je 0x58aad
movabsq $-0x200000000, %rcx     # imm = 0xFFFFFFFE00000000
xorl %r15d, %r15d
movabsq $0x100000000, %rsi      # imm = 0x100000000
addq %rsi, %rcx
movb (%rax,%r15), %dl
incq %r15
testb %dl, %dl
je 0x58a1b
cmpb %r10b, %dl
je 0x58a1b
cmpb %r11b, %dl
je 0x58a1b
cmpb %bl, %dl
jne 0x589ff
cmpq $0x1, %r15
movq -0x68(%rbp), %rbx
je 0x58ab1
sarq $0x20, %rcx
cmpb $-0x1, (%rax,%rcx)
je 0x58ab1
movq %r9, %rbx
movq %rdi, %r12
movl $0x0, -0x50(%rbp)
cmpb %r10b, %dl
jne 0x58a54
movl %r15d, %ecx
xorl %edx, %edx
cmpb $0x0, (%rax,%rcx)
sete %dl
movl %edx, -0x50(%rbp)
movq %r14, %rdi
movl $0x5e, %esi
movq %rax, %rdx
callq 0x3db22
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x58a7b
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, -0x1(%rax,%r15)
cmpb $-0x7b, -0x74(%rbp)
movq %r12, %rdi
jne 0x58cf3
movq -0x70(%rbp), %rax
movq 0x10(%rax), %r15
movswl 0x30(%rbx), %ecx
cmpl $0x21, %ecx
jl 0x58c1f
movl $0xffffffff, 0x104(%r15) # imm = 0xFFFFFFFF
jmp 0x58c2f
movq -0x68(%rbp), %rbx
callq 0x142f2
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %r11
movq %r12, %r8
cmpb $-0x69, (%r11)
jne 0x58c09
movq 0x8(%r11), %rcx
movb (%rcx), %sil
testb %sil, %sil
je 0x58b12
movq %r8, %r14
incq %rcx
leaq 0x2471c(%rip), %rax     # 0x7d200
leaq 0x1d5c5(%rip), %rdx     # 0x760b0
movzbl %sil, %esi
movb (%rsi,%rdx), %r9b
movzbl (%rax), %r8d
cmpb (%r8,%rdx), %r9b
jne 0x58b0d
incq %rax
movb (%rcx), %sil
incq %rcx
testb %sil, %sil
jne 0x58aeb
xorl %esi, %esi
movq %r14, %r8
jmp 0x58b1b
leaq 0x246e7(%rip), %rax     # 0x7d200
xorl %esi, %esi
leaq 0x1d58e(%rip), %rcx     # 0x760b0
movb (%rsi,%rcx), %dl
movzbl (%rax), %eax
cmpb (%rax,%rcx), %dl
jne 0x58c09
movq 0x20(%r11), %rax
cmpl $0x2, (%rax)
jne 0x58c09
movq 0x8(%rax), %rax
movq 0x20(%rax), %r14
cmpb $-0x68, (%r14)
jne 0x58c09
movq (%rax), %rsi
movq %rsi, -0x38(%rbp)
movq %r13, %r15
movq %rdi, %r13
movq %r8, -0x30(%rbp)
callq 0x58edf
movq %rax, %r12
movq %r13, %rdi
movq %r15, %r13
movq %r14, %rsi
callq 0x58edf
movq -0x30(%rbp), %r8
testq %r12, %rax
jne 0x58c09
movq -0x80(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
movq -0x70(%rbp), %rdi
movl $0x32, %esi
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x3a637
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x57b6d
movq 0x20(%r15), %rcx
cltq
imulq $0x38, %rax, %rax
movq %r12, 0x28(%rcx,%rax)
movl 0x2c(%r14), %edx
movl %edx, 0xc(%rcx,%rax)
movswl 0x30(%r14), %edx
movl %edx, 0x10(%rcx,%rax)
movw $0x40, 0x18(%rcx,%rax)
movl -0x5c(%rbp), %edx
movl %edx, 0x8(%rcx,%rax)
movq 0x20(%r15), %rdx
movb $0x1, 0x1b(%rdx,%rbx)
orb $0x8, 0x1a(%rdx,%rbx)
leaq (%rdx,%rbx), %r8
movq 0x30(%rdx,%rbx), %rdx
movq %rdx, 0x30(%rcx,%rax)
orq %r13, 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(%r15)
cmpl $0x0, -0x50(%rbp)
movq -0x58(%rbp), %r13
movq %r12, %rdi
je 0x58cf3
movq 0x8(%rbx), %rax
cmpb $0x0, 0x1(%rax)
je 0x58cf3
movq -0x70(%rbp), %rax
movb 0x1f(%rax), %al
testb %al, %al
je 0x58c6c
decb %al
movq -0x70(%rbp), %rcx
movb %al, 0x1f(%rcx)
movzbl %al, %eax
movl 0x28(%rcx,%rax,4), %r14d
jmp 0x58c7b
movq -0x70(%rbp), %rax
movl 0x58(%rax), %r14d
incl %r14d
movl %r14d, 0x58(%rax)
movq -0x70(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x4d33b
movl 0x34(%r15), %eax
testl %eax, %eax
je 0x58ca4
decl %eax
movq 0x8(%r15), %rcx
leaq (%rax,%rax,2), %rax
movl $0x0, 0xc(%rcx,%rax,8)
testl %r14d, %r14d
movq -0x58(%rbp), %r13
movq %r12, %rdi
je 0x58cf3
movq -0x70(%rbp), %rax
movzbl 0x1f(%rax), %eax
cmpq $0x7, %rax
ja 0x58cf3
xorl %ecx, %ecx
movq -0x70(%rbp), %rdx
cmpl %r14d, 0x84(%rdx,%rcx)
je 0x58ce7
addq $0x18, %rcx
cmpl $0xf0, %ecx
jne 0x58cc4
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rdx)
movl %r14d, 0x28(%rdx,%rax,4)
jmp 0x58cec
movb $0x1, 0x7c(%rdx,%rcx)
movq -0x58(%rbp), %r13
movq %r12, %rdi
callq 0x142f2
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %r15
movq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
cmpb $0x0, 0x50(%rbx)
movq %rax, -0x88(%rbp)
je 0x58d2f
movq -0x68(%rbp), %rbx
jmp 0x58d8a
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x58d52
movq $-0x1, %rcx
cmpb $0x0, 0x1(%rax,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x58d3f
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
jmp 0x58d54
xorl %ecx, %ecx
movb -0x1(%rax,%rcx), %dl
testb $0x2, -0x90(%rbp)
jne 0x58d7c
movzbl %dl, %edx
xorl %esi, %esi
cmpb $0x40, %dl
movl -0x50(%rbp), %edi
cmovel %esi, %edi
movl %edi, -0x50(%rbp)
leaq 0x1d337(%rip), %rsi     # 0x760b0
movb (%rdx,%rsi), %dl
incb %dl
movb %dl, -0x1(%rax,%rcx)
movq -0x68(%rbp), %rbx
movq -0x58(%rbp), %r13
testb $0x2, -0x90(%rbp)
leaq 0x22d1e(%rip), %rax     # 0x7bab6
leaq 0x2279f(%rip), %rcx     # 0x7b53e
cmoveq %rax, %rcx
leaq -0xc8(%rbp), %r12
movq %rcx, (%r12)
movl $0x6, 0x8(%r12)
movq -0x80(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
movq -0x70(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x40a7d
movq %r14, %rdi
movl $0x50, %esi
movq %rax, %rdx
movq -0x30(%rbp), %rcx
xorl %r8d, %r8d
callq 0x3a637
testq %rax, %rax
je 0x58e0c
movq -0x38(%rbp), %rdx
movzwl 0x2(%rdx), %ecx
andl $0x1, %ecx
orw %cx, 0x2(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x57b6d
movl %eax, %r12d
movq %r14, %rdi
movl %eax, %esi
callq 0x57c97
movq -0x80(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
leaq -0xc8(%rbp), %rdx
movq -0x70(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x40a7d
movq %r14, %rdi
movl $0x4f, %esi
movq %rax, %rdx
movq -0x88(%rbp), %rcx
xorl %r8d, %r8d
callq 0x3a637
testq %rax, %rax
je 0x58e89
movq -0x38(%rbp), %rdx
movzwl 0x2(%rdx), %ecx
andl $0x1, %ecx
orw %cx, 0x2(%rax)
movzwl 0x34(%rdx), %ecx
movw %cx, 0x34(%rax)
movq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl $0x3, %edx
callq 0x57b6d
movl %eax, %r14d
movq %r15, %rdi
movl %eax, %esi
callq 0x57c97
movq 0x20(%r15), %rax
leaq (%rax,%rbx), %r8
cmpl $0x0, -0x50(%rbp)
je 0x58ed6
movslq %r12d, %rcx
imulq $0x38, %rcx, %rcx
movl -0x5c(%rbp), %edx
movl %edx, 0x8(%rax,%rcx)
movslq %r14d, %rcx
imulq $0x38, %rcx, %rcx
movl %edx, 0x8(%rax,%rcx)
movb $0x2, 0x1b(%r8)
movq -0x40(%rbp), %rdi
jmp 0x58975