// File: /workspace/github_c_makefile_star2_O0/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
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpb $0x0, 0x51(%rax)
je 0x87084
jmp 0x87b4d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x54, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x87b60
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x64(%rbp)
cmpl $0x4b, -0x64(%rbp)
jne 0x87124
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x87106
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x87c40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x87122
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x84070
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x87156
cmpl $0x4c, -0x64(%rbp)
jne 0x87138
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x87154
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x87b60
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x87156
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x87b60
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x871ac
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movswl 0x34(%rax), %esi
callq 0x87d80
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
orq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x88(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movw $0x0, 0x1a(%rax)
movl -0x64(%rbp), %edi
callq 0x87de0
cmpl $0x0, %eax
je 0x874a0
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x70830
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x70830
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdx
andq -0x40(%rbp), %rdx
movl $0x800, %eax            # imm = 0x800
movl $0x1fff, %ecx           # imm = 0x1FFF
cmpq $0x0, %rdx
cmovel %ecx, %eax
movw %ax, -0xa2(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x8c(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0x87e30
cmpl $0x0, %eax
je 0x87295
movl -0x8c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x90(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x64(%rbp), %edi
callq 0x87fe0
movzwl %ax, %eax
movzwl -0xa2(%rbp), %ecx
andl %ecx, %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x1a(%rax)
cmpl $0x49, -0x64(%rbp)
jne 0x872ad
movq -0x28(%rbp), %rax
movzwl 0x1c(%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
movw %cx, 0x1c(%rax)
cmpq $0x0, -0xa0(%rbp)
je 0x8749b
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x8c(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0x87e30
cmpl $0x0, %eax
je 0x8749b
movw $0x0, -0xba(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jl 0x87401
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x713e0
movq %rax, -0xb8(%rbp)
movq -0x78(%rbp), %rax
cmpb $0x0, 0x51(%rax)
je 0x87336
movq -0x78(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x536c0
jmp 0x87b4d
movq -0x10(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movl $0x3, %edx
callq 0x86e30
movl %eax, -0xc0(%rbp)
cmpl $0x0, -0xc0(%rbp)
jne 0x8735f
jmp 0x87b4d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc0(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movl -0xc0(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x88030
cmpl $0x49, -0x64(%rbp)
jne 0x873a9
movq -0xb0(%rbp), %rax
movzwl 0x1c(%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
movw %cx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x1c(%rax), %ecx
orl $0x8, %ecx
movw %cx, 0x1c(%rax)
movq -0x70(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x880b0
cmpl $0x0, %eax
je 0x873ff
movq -0x28(%rbp), %rax
movzwl 0x1a(%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
movw %cx, 0x1a(%rax)
movw $0x800, -0xba(%rbp)     # imm = 0x800
jmp 0x87417
movq -0x38(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x70(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x88250
movl -0x8c(%rbp), %ecx
movq -0xb0(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x90(%rbp), %ecx
movq -0xb0(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x40(%rbp), %rcx
orq -0x50(%rbp), %rcx
movq -0xb0(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x48(%rbp), %rcx
movq -0xb0(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0xb8(%rbp), %rax
movzbl (%rax), %edi
callq 0x87fe0
movzwl %ax, %eax
movzwl -0xba(%rbp), %ecx
addl %ecx, %eax
movzwl -0xa2(%rbp), %ecx
andl %ecx, %eax
movw %ax, %cx
movq -0xb0(%rbp), %rax
movw %cx, 0x1a(%rax)
jmp 0x87627
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x4a, %eax
jne 0x875f0
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x48, %eax
jne 0x875f0
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xcc(%rbp)
cmpl $0x2, -0xcc(%rbp)
jge 0x875ee
movq -0x70(%rbp), %rax
movq %rax, -0x178(%rbp)
movslq -0xcc(%rbp), %rcx
leaq 0x1deb1(%rip), %rax     # 0xa53b1
movzbl (%rax,%rcx), %eax
movl %eax, -0x16c(%rbp)
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0x713e0
movq %rax, -0x168(%rbp)
movq -0x78(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xcc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x713e0
movq -0x178(%rbp), %rdi
movl -0x16c(%rbp), %esi
movq -0x168(%rbp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x5d170
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x88340
movq -0x10(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movl $0x3, %edx
callq 0x86e30
movl %eax, -0xdc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0xdc(%rbp), %edx
callq 0x87020
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0xdc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x88030
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x874da
jmp 0x87625
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x47, %eax
jne 0x87623
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x88380
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x87625
jmp 0x87627
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x48, %eax
jne 0x8799a
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0x5c(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x88b90
cmpl $0x0, %eax
je 0x8799a
movw $0x103, -0x112(%rbp)    # imm = 0x103
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0xe8(%rbp)
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x713e0
movq %rax, -0xf0(%rbp)
cmpl $0x0, -0x60(%rbp)
je 0x8775c
movq -0x70(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x51(%rax)
jne 0x8775c
movq -0x28(%rbp), %rax
movzwl 0x1c(%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movw %cx, 0x1c(%rax)
movl $0x0, -0x118(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x118(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x119(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x8775a
movsbl -0x119(%rbp), %eax
movzbl -0x119(%rbp), %ecx
movl %ecx, %edx
leaq 0x1b6a2(%rip), %rcx     # 0xa2da0
movzbl (%rcx,%rdx), %ecx
andl $0x20, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movb %al, %dl
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x118(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0x119(%rbp), %eax
movl %eax, %ecx
leaq 0x1b512(%rip), %rax     # 0xa2c40
movb (%rax,%rcx), %dl
movq -0xf0(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x118(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x118(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x118(%rbp)
jmp 0x876c7
jmp 0x8775c
movq -0x78(%rbp), %rax
cmpb $0x0, 0x51(%rax)
jne 0x877fb
movq -0xf0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x180(%rbp)
movq -0xf0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc6c0
movl %eax, %ecx
movq -0x180(%rbp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movb (%rax), %al
movb %al, -0x11a(%rbp)
cmpl $0x0, -0x60(%rbp)
je 0x877e6
movzbl -0x11a(%rbp), %eax
cmpl $0x40, %eax
jne 0x877cd
movl $0x0, -0x5c(%rbp)
movzbl -0x11a(%rbp), %eax
movl %eax, %ecx
leaq 0x1b463(%rip), %rax     # 0xa2c40
movb (%rax,%rcx), %al
movb %al, -0x11a(%rbp)
movzbl -0x11a(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x128(%rbp), %rax
movb %cl, (%rax)
movl -0x60(%rbp), %edx
leaq 0x1ec25(%rip), %rax     # 0xa642a
leaq 0x20b4d(%rip), %rcx     # 0xa8359
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x110(%rbp)
movq -0x78(%rbp), %rdi
movq -0xe8(%rbp), %rsi
xorl %edx, %edx
callq 0x713e0
movq %rax, -0xf8(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x70(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movq -0x110(%rbp), %rdx
callq 0x76c10
movq -0x190(%rbp), %rdi
movq %rax, %rdx
movq -0x58(%rbp), %rcx
movl $0x53, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x5d170
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x88340
movq -0x10(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movl $0x103, %edx            # imm = 0x103
callq 0x86e30
movl %eax, -0x104(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x104(%rbp), %edx
callq 0x87020
movq -0x78(%rbp), %rdi
movq -0xe8(%rbp), %rsi
xorl %edx, %edx
callq 0x713e0
movq %rax, -0x100(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x70(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0x110(%rbp), %rdx
callq 0x76c10
movq -0x188(%rbp), %rdi
movq %rax, %rdx
movq -0xf0(%rbp), %rcx
movl $0x52, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x5d170
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x88340
movq -0x10(%rbp), %rdi
movq -0x100(%rbp), %rsi
movl $0x103, %edx            # imm = 0x103
callq 0x86e30
movl %eax, -0x108(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x108(%rbp), %edx
callq 0x87020
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x87998
movq -0x10(%rbp), %rdi
movl -0x104(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x88030
movq -0x10(%rbp), %rdi
movl -0x108(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x88030
jmp 0x8799a
movq -0x38(%rbp), %rdi
leaq -0x79(%rbp), %rsi
callq 0x88f00
cmpl $0x0, %eax
je 0x87b3d
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x30(%rbp), %rdi
movq -0x138(%rbp), %rsi
callq 0x87b60
movq %rax, -0x158(%rbp)
movq -0x30(%rbp), %rdi
movq -0x140(%rbp), %rsi
callq 0x87b60
movq %rax, -0x150(%rbp)
movq -0x158(%rbp), %rax
andq -0x150(%rbp), %rax
cmpq $0x0, %rax
jne 0x87b3b
movq -0x70(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x78(%rbp), %rdi
movq -0x138(%rbp), %rsi
xorl %edx, %edx
callq 0x713e0
movq -0x198(%rbp), %rdi
movq %rax, %rcx
movl $0x33, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x5d170
movq %rax, -0x160(%rbp)
movq -0x10(%rbp), %rdi
movq -0x160(%rbp), %rsi
movl $0x3, %edx
callq 0x86e30
movl %eax, -0x12c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x12c(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x148(%rbp)
movq -0x158(%rbp), %rcx
movq -0x148(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x140(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x148(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x140(%rbp), %rax
movswl 0x30(%rax), %ecx
movq -0x148(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x148(%rbp), %rax
movw $0x40, 0x1a(%rax)
movb -0x79(%rbp), %cl
movq -0x148(%rbp), %rax
movb %cl, 0x1f(%rax)
movq -0x10(%rbp), %rdi
movl -0x12c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x88030
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x1c(%rax), %ecx
orl $0x8, %ecx
movw %cx, 0x1c(%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x148(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x87b3d
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
orq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
nopw %cs:(%rax,%rax)