// File: /workspace/github_c_makefile_star2_O0/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
subq $0x190, %rsp            # imm = 0x190
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, 0x50(%rax)
je 0x756c4
jmp 0x760bd
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 $0x4c, %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 0x760d0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x64(%rbp)
cmpl $0x48, -0x64(%rbp)
jne 0x75767
movq -0x38(%rbp), %rax
movzwl 0x2(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x800, %eax            # imm = 0x800
jne 0x75749
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x761b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x75765
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x72be0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x75799
cmpl $0x49, -0x64(%rbp)
jne 0x7577b
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x75797
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x760d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x75799
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x760d0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movzwl 0x2(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x757e7
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movswl 0x34(%rax), %esi
callq 0x72c50
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
orq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x80(%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, 0x18(%rax)
movl -0x64(%rbp), %edi
callq 0x762f0
cmpl $0x0, %eax
je 0x75abc
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x648b0
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x648b0
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdx
andq -0x40(%rbp), %rdx
movl $0x400, %eax            # imm = 0x400
movl $0xfff, %ecx            # imm = 0xFFF
cmpq $0x0, %rdx
cmovel %ecx, %eax
movw %ax, -0x92(%rbp)
movq -0x88(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x98, %eax
jne 0x758c3
movq -0x88(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x88(%rbp), %rax
movswl 0x30(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x64(%rbp), %edi
callq 0x76330
movzwl %ax, %eax
movzwl -0x92(%rbp), %ecx
andl %ecx, %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, 0x18(%rax)
cmpq $0x0, -0x90(%rbp)
je 0x75ab7
movq -0x90(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x98, %eax
jne 0x75ab7
movw $0x0, -0xaa(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jl 0x759fd
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0xa8(%rbp)
movq -0x78(%rbp), %rax
cmpb $0x0, 0x50(%rax)
je 0x75932
movq -0x78(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x47330
jmp 0x760bd
movq -0x10(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl $0x3, %edx
callq 0x754e0
movl %eax, -0xb0(%rbp)
cmpl $0x0, -0xb0(%rbp)
jne 0x7595b
jmp 0x760bd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xb0(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xa0(%rbp)
movl -0x14(%rbp), %ecx
movq -0xa0(%rbp), %rax
movl %ecx, 0x8(%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
movb $0x1, 0x1b(%rax)
movq -0x28(%rbp), %rax
movzbl 0x1a(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x1a(%rax)
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x759fb
movq -0x38(%rbp), %rax
movzwl 0x2(%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x759fb
movq -0x78(%rbp), %rax
movzwl 0x4c(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x759fb
movq -0x28(%rbp), %rax
movzwl 0x18(%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movw %cx, 0x18(%rax)
movw $0x400, -0xaa(%rbp)     # imm = 0x400
jmp 0x75a13
movq -0x38(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x70(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x76370
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x648b0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0xa0(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x88(%rbp), %rax
movswl 0x30(%rax), %ecx
movq -0xa0(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x40(%rbp), %rcx
orq -0x50(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x48(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0xa8(%rbp), %rax
movzbl (%rax), %edi
callq 0x76330
movzwl %ax, %eax
movzwl -0xaa(%rbp), %ecx
addl %ecx, %eax
movzwl -0x92(%rbp), %ecx
andl %ecx, %eax
movw %ax, %cx
movq -0xa0(%rbp), %rax
movw %cx, 0x18(%rax)
jmp 0x75c55
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x47, %eax
jne 0x75c1e
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x45, %eax
jne 0x75c1e
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0xbc(%rbp)
cmpl $0x2, -0xbc(%rbp)
jge 0x75c14
movq -0x70(%rbp), %rax
movq %rax, -0x168(%rbp)
movslq -0xbc(%rbp), %rcx
leaq 0x378d8(%rip), %rax     # 0xad3f4
movzbl (%rax,%rcx), %eax
movl %eax, -0x15c(%rbp)
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0x158(%rbp)
movq -0x78(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xbc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x61690
movq -0x168(%rbp), %rdi
movl -0x15c(%rbp), %esi
movq -0x158(%rbp), %rdx
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x76460
movq -0x10(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movl $0x3, %edx
callq 0x754e0
movl %eax, -0xcc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0xcc(%rbp), %edx
callq 0x75660
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xcc(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
jmp 0x75af6
movq -0x28(%rbp), %rax
movb $0x2, 0x1b(%rax)
jmp 0x75c53
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x44, %eax
jne 0x75c51
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x764a0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x75c53
jmp 0x75c55
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x45, %eax
jne 0x75f19
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0x5c(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x76c20
cmpl $0x0, %eax
je 0x75f19
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x78(%rbp), %rdi
movq -0x58(%rbp), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0xe0(%rbp)
movq -0x78(%rbp), %rax
cmpb $0x0, 0x50(%rax)
jne 0x75d54
movq -0xe0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x170(%rbp)
movq -0xe0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x92f0
movl %eax, %ecx
movq -0x170(%rbp), %rax
subl $0x1, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
movb (%rax), %al
movb %al, -0x109(%rbp)
cmpl $0x0, -0x60(%rbp)
je 0x75d3f
movzbl -0x109(%rbp), %eax
cmpl $0x40, %eax
jne 0x75d26
movl $0x0, -0x5c(%rbp)
movzbl -0x109(%rbp), %eax
movl %eax, %ecx
leaq 0x34e0a(%rip), %rax     # 0xaab40
movb (%rax,%rcx), %al
movb %al, -0x109(%rbp)
movzbl -0x109(%rbp), %eax
addl $0x1, %eax
movb %al, %cl
movq -0x118(%rbp), %rax
movb %cl, (%rax)
movl -0x60(%rbp), %edx
leaq 0x3a2dc(%rip), %rax     # 0xb003a
leaq 0x3a84d(%rip), %rcx     # 0xb05b2
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x108(%rbp)
movl $0x6, -0x100(%rbp)
movq -0x78(%rbp), %rdi
movq -0xd8(%rbp), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0xe8(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x70(%rbp), %rdi
movq -0xe8(%rbp), %rsi
leaq -0x108(%rbp), %rdx
callq 0x57e10
movq -0x180(%rbp), %rdi
movq %rax, %rdx
movq -0x58(%rbp), %rcx
movl $0x50, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x76460
movq -0x10(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movl $0x3, %edx
callq 0x754e0
movl %eax, -0xf4(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0xf4(%rbp), %edx
callq 0x75660
movq -0x78(%rbp), %rdi
movq -0xd8(%rbp), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0xf0(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x70(%rbp), %rdi
movq -0xf0(%rbp), %rsi
leaq -0x108(%rbp), %rdx
callq 0x57e10
movq -0x178(%rbp), %rdi
movq %rax, %rdx
movq -0xe0(%rbp), %rcx
movl $0x4f, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x76460
movq -0x10(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movl $0x3, %edx
callq 0x754e0
movl %eax, -0xf8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0xf8(%rbp), %edx
callq 0x75660
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 0x75f17
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xf4(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xf8(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movb $0x2, 0x1b(%rax)
jmp 0x75f19
movq -0x38(%rbp), %rdi
callq 0x76fa0
cmpl $0x0, %eax
je 0x760ad
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x130(%rbp)
movq -0x30(%rbp), %rdi
movq -0x128(%rbp), %rsi
callq 0x760d0
movq %rax, -0x148(%rbp)
movq -0x30(%rbp), %rdi
movq -0x130(%rbp), %rsi
callq 0x760d0
movq %rax, -0x140(%rbp)
movq -0x148(%rbp), %rax
andq -0x140(%rbp), %rax
cmpq $0x0, %rax
jne 0x760ab
movq -0x70(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x78(%rbp), %rdi
movq -0x128(%rbp), %rsi
xorl %edx, %edx
callq 0x61690
movq -0x188(%rbp), %rdi
movq %rax, %rcx
movl $0x32, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x508b0
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rdi
movq -0x150(%rbp), %rsi
movl $0x3, %edx
callq 0x754e0
movl %eax, -0x11c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x11c(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x138(%rbp)
movq -0x148(%rbp), %rcx
movq -0x138(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x130(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x138(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x130(%rbp), %rax
movswl 0x30(%rax), %ecx
movq -0x138(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x138(%rbp), %rax
movw $0x40, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x138(%rbp), %rax
movl %ecx, 0x8(%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
movb $0x1, 0x1b(%rax)
movq -0x28(%rbp), %rax
movzbl 0x1a(%rax), %ecx
orl $0x8, %ecx
movb %cl, 0x1a(%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x138(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x760ad
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
orq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
nopw %cs:(%rax,%rax)