// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: exprAnalyzeOrTerm
static void exprAnalyzeOrTerm(
  SrcList *pSrc,            /* the FROM clause */
  WhereClause *pWC,         /* the complete WHERE clause */
  int idxTerm               /* Index of the OR-term to be analyzed */
){
  WhereInfo *pWInfo = pWC->pWInfo;        /* WHERE clause processing context */
  Parse *pParse = pWInfo->pParse;         /* Parser context */
  sqlite3 *db = pParse->db;               /* Database connection */
  WhereTerm *pTerm = &pWC->a[idxTerm];    /* The term to be analyzed */
  Expr *pExpr = pTerm->pExpr;             /* The expression of the term */
  int i;                                  /* Loop counters */
  WhereClause *pOrWc;       /* Breakup of pTerm into subterms */
  WhereTerm *pOrTerm;       /* A Sub-term within the pOrWc */
  WhereOrInfo *pOrInfo;     /* Additional information associated with pTerm */
  Bitmask chngToIN;         /* Tables that might satisfy case 1 */
  Bitmask indexable;        /* Tables that are indexable, satisfying case 2 */

  /*
  ** Break the OR clause into its separate subterms.  The subterms are
  ** stored in a WhereClause structure containing within the WhereOrInfo
  ** object that is attached to the original OR clause term.
  */
  assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
  assert( pExpr->op==TK_OR );
  pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
  if( pOrInfo==0 ) return;
  pTerm->wtFlags |= TERM_ORINFO;
  pOrWc = &pOrInfo->wc;
  memset(pOrWc->aStatic, 0, sizeof(pOrWc->aStatic));
  sqlite3WhereClauseInit(pOrWc, pWInfo);
  sqlite3WhereSplit(pOrWc, pExpr, TK_OR);
  sqlite3WhereExprAnalyze(pSrc, pOrWc);
  if( db->mallocFailed ) return;
  assert( pOrWc->nTerm>=2 );

  /*
  ** Compute the set of tables that might satisfy cases 1 or 3.
  */
  indexable = ~(Bitmask)0;
  chngToIN = ~(Bitmask)0;
  for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){
    if( (pOrTerm->eOperator & WO_SINGLE)==0 ){
      WhereAndInfo *pAndInfo;
      assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
      chngToIN = 0;
      pAndInfo = sqlite3DbMallocRawNN(db, sizeof(*pAndInfo));
      if( pAndInfo ){
        WhereClause *pAndWC;
        WhereTerm *pAndTerm;
        int j;
        Bitmask b = 0;
        pOrTerm->u.pAndInfo = pAndInfo;
        pOrTerm->wtFlags |= TERM_ANDINFO;
        pOrTerm->eOperator = WO_AND;
        pAndWC = &pAndInfo->wc;
        memset(pAndWC->aStatic, 0, sizeof(pAndWC->aStatic));
        sqlite3WhereClauseInit(pAndWC, pWC->pWInfo);
        sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
        sqlite3WhereExprAnalyze(pSrc, pAndWC);
        pAndWC->pOuter = pWC;
        if( !db->mallocFailed ){
          for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
            assert( pAndTerm->pExpr );
            if( allowedOp(pAndTerm->pExpr->op)
             || pAndTerm->eOperator==WO_AUX
            ){
              b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pAndTerm->leftCursor);
            }
          }
        }
        indexable &= b;
      }
    }else if( pOrTerm->wtFlags & TERM_COPIED ){
      /* Skip this term for now.  We revisit it when we process the
      ** corresponding TERM_VIRTUAL term */
    }else{
      Bitmask b;
      b = sqlite3WhereGetMask(&pWInfo->sMaskSet, pOrTerm->leftCursor);
      if( pOrTerm->wtFlags & TERM_VIRTUAL ){
        WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent];
        b |= sqlite3WhereGetMask(&pWInfo->sMaskSet, pOther->leftCursor);
      }
      indexable &= b;
      if( (pOrTerm->eOperator & WO_EQ)==0 ){
        chngToIN = 0;
      }else{
        chngToIN &= b;
      }
    }
  }

  /*
  ** Record the set of tables that satisfy case 3.  The set might be
  ** empty.
  */
  pOrInfo->indexable = indexable;
  if( indexable ){
    pTerm->eOperator = WO_OR;
    pWC->hasOr = 1;
  }else{
    pTerm->eOperator = WO_OR;
  }

  /* For a two-way OR, attempt to implementation case 2.
  */
  if( indexable && pOrWc->nTerm==2 ){
    int iOne = 0;
    WhereTerm *pOne;
    while( (pOne = whereNthSubterm(&pOrWc->a[0],iOne++))!=0 ){
      int iTwo = 0;
      WhereTerm *pTwo;
      while( (pTwo = whereNthSubterm(&pOrWc->a[1],iTwo++))!=0 ){
        whereCombineDisjuncts(pSrc, pWC, pOne, pTwo);
      }
    }
  }

  /*
  ** chngToIN holds a set of tables that *might* satisfy case 1.  But
  ** we have to do some additional checking to see if case 1 really
  ** is satisfied.
  **
  ** chngToIN will hold either 0, 1, or 2 bits.  The 0-bit case means
  ** that there is no possibility of transforming the OR clause into an
  ** IN operator because one or more terms in the OR clause contain
  ** something other than == on a column in the single table.  The 1-bit
  ** case means that every term of the OR clause is of the form
  ** "table.column=expr" for some single table.  The one bit that is set
  ** will correspond to the common table.  We still need to check to make
  ** sure the same column is used on all terms.  The 2-bit case is when
  ** the all terms are of the form "table1.column=table2.column".  It
  ** might be possible to form an IN operator with either table1.column
  ** or table2.column as the LHS if either is common to every term of
  ** the OR clause.
  **
  ** Note that terms of the form "table.column1=table.column2" (the
  ** same table on both sizes of the ==) cannot be optimized.
  */
  if( chngToIN ){
    int okToChngToIN = 0;     /* True if the conversion to IN is valid */
    int iColumn = -1;         /* Column index on lhs of IN operator */
    int iCursor = -1;         /* Table cursor common to all terms */
    int j = 0;                /* Loop counter */

    /* Search for a table and column that appears on one side or the
    ** other of the == operator in every subterm.  That table and column
    ** will be recorded in iCursor and iColumn.  There might not be any
    ** such table and column.  Set okToChngToIN if an appropriate table
    ** and column is found but leave okToChngToIN false if not found.
    */
    for(j=0; j<2 && !okToChngToIN; j++){
      Expr *pLeft = 0;
      pOrTerm = pOrWc->a;
      for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){
        assert( pOrTerm->eOperator & WO_EQ );
        pOrTerm->wtFlags &= ~TERM_OR_OK;
        if( pOrTerm->leftCursor==iCursor ){
          /* This is the 2-bit case and we are on the second iteration and
          ** current term is from the first iteration.  So skip this term. */
          assert( j==1 );
          continue;
        }
        if( (chngToIN & sqlite3WhereGetMask(&pWInfo->sMaskSet,
                                            pOrTerm->leftCursor))==0 ){
          /* This term must be of the form t1.a==t2.b where t2 is in the
          ** chngToIN set but t1 is not.  This term will be either preceded
          ** or follwed by an inverted copy (t2.b==t1.a).  Skip this term
          ** and use its inversion. */
          testcase( pOrTerm->wtFlags & TERM_COPIED );
          testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
          assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
          continue;
        }
        iColumn = pOrTerm->u.leftColumn;
        iCursor = pOrTerm->leftCursor;
        pLeft = pOrTerm->pExpr->pLeft;
        break;
      }
      if( i<0 ){
        /* No candidate table+column was found.  This can only occur
        ** on the second iteration */
        assert( j==1 );
        assert( IsPowerOfTwo(chngToIN) );
        assert( chngToIN==sqlite3WhereGetMask(&pWInfo->sMaskSet, iCursor) );
        break;
      }
      testcase( j==1 );

      /* We have found a candidate table and column.  Check to see if that
      ** table and column is common to every term in the OR clause */
      okToChngToIN = 1;
      for(; i>=0 && okToChngToIN; i--, pOrTerm++){
        assert( pOrTerm->eOperator & WO_EQ );
        if( pOrTerm->leftCursor!=iCursor ){
          pOrTerm->wtFlags &= ~TERM_OR_OK;
        }else if( pOrTerm->u.leftColumn!=iColumn || (iColumn==XN_EXPR
               && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
        )){
          okToChngToIN = 0;
        }else{
          int affLeft, affRight;
          /* If the right-hand side is also a column, then the affinities
          ** of both right and left sides must be such that no type
          ** conversions are required on the right.  (Ticket #2249)
          */
          affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
          affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
          if( affRight!=0 && affRight!=affLeft ){
            okToChngToIN = 0;
          }else{
            pOrTerm->wtFlags |= TERM_OR_OK;
          }
        }
      }
    }

    /* At this point, okToChngToIN is true if original pTerm satisfies
    ** case 1.  In that case, construct a new virtual term that is
    ** pTerm converted into an IN operator.
    */
    if( okToChngToIN ){
      Expr *pDup;            /* A transient duplicate expression */
      ExprList *pList = 0;   /* The RHS of the IN operator */
      Expr *pLeft = 0;       /* The LHS of the IN operator */
      Expr *pNew;            /* The complete IN operator */

      for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){
        if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue;
        assert( pOrTerm->eOperator & WO_EQ );
        assert( pOrTerm->leftCursor==iCursor );
        assert( pOrTerm->u.leftColumn==iColumn );
        pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
        pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup);
        pLeft = pOrTerm->pExpr->pLeft;
      }
      assert( pLeft!=0 );
      pDup = sqlite3ExprDup(db, pLeft, 0);
      pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0);
      if( pNew ){
        int idxNew;
        transferJoinMarkings(pNew, pExpr);
        assert( !ExprHasProperty(pNew, EP_xIsSelect) );
        pNew->x.pList = pList;
        idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
        testcase( idxNew==0 );
        exprAnalyze(pSrc, pWC, idxNew);
        /* pTerm = &pWC->a[idxTerm]; // would be needed if pTerm where used again */
        markTermAsChild(pWC, idxNew, idxTerm);
      }else{
        sqlite3ExprListDelete(db, pList);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movl $0x230, %esi            # imm = 0x230
callq 0x3c9520
movq %rax, %rcx
movq %rcx, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x60(%rbp)
jne 0x44ee12
jmp 0x44f60e
movq -0x38(%rbp), %rax
movzwl 0x12(%rax), %ecx
orl $0x10, %ecx
movw %cx, 0x12(%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x19360
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4488b0
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x2b, %edx
callq 0x448910
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x448bc0
movq -0x30(%rbp), %rax
cmpb $0x0, 0x61(%rax)
je 0x44ee78
jmp 0x44f60e
movq $-0x1, -0x70(%rbp)
movq $-0x1, -0x68(%rbp)
movq -0x50(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x44(%rbp)
movb %al, -0x10d(%rbp)
jl 0x44eebd
cmpq $0x0, -0x70(%rbp)
setne %al
movb %al, -0x10d(%rbp)
movb -0x10d(%rbp), %al
testb $0x1, %al
jne 0x44eecc
jmp 0x44f135
movq -0x58(%rbp), %rax
movzwl 0x14(%rax), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl $0x0, %eax
jne 0x44f054
movq $0x0, -0x68(%rbp)
movq -0x30(%rbp), %rdi
movl $0x228, %esi            # imm = 0x228
callq 0x3d62a0
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x44f04f
movq $0x0, -0x98(%rbp)
movq -0x78(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x58(%rbp), %rax
movzwl 0x12(%rax), %ecx
orl $0x20, %ecx
movw %cx, 0x12(%rax)
movq -0x58(%rbp), %rax
movw $0x400, 0x14(%rax)      # imm = 0x400
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
addq $0x28, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x19360
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4488b0
movq -0x80(%rbp), %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rsi
movl $0x2c, %edx
callq 0x448910
movq -0x8(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x448bc0
movq -0x10(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x61(%rax)
jne 0x44f040
movl $0x0, -0x8c(%rbp)
movq -0x80(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x88(%rbp)
movl -0x8c(%rbp), %eax
movq -0x80(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x44f03e
movq -0x88(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %edi
callq 0x44e970
cmpl $0x0, %eax
jne 0x44efee
movq -0x88(%rbp), %rax
movzwl 0x14(%rax), %eax
cmpl $0x40, %eax
jne 0x44f016
movq -0x20(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
movq -0x88(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x44e910
orq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x44f018
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
movq -0x88(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x88(%rbp)
jmp 0x44efb8
jmp 0x44f040
movq -0x98(%rbp), %rax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x44f119
movq -0x58(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x44f069
jmp 0x44f117
movq -0x20(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
movq -0x58(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x44e910
movq %rax, -0xa0(%rbp)
movq -0x58(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x44f0dd
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x58(%rbp), %rcx
movslq 0x18(%rcx), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
movq -0xa8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x44e910
orq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rax
movzwl 0x14(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x44f106
movq $0x0, -0x68(%rbp)
jmp 0x44f115
movq -0xa0(%rbp), %rax
andq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x44f117
jmp 0x44f119
jmp 0x44f11b
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
jmp 0x44eea1
movq -0x70(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x228(%rax)
cmpq $0x0, -0x70(%rbp)
je 0x44f15f
movq -0x38(%rbp), %rax
movw $0x200, 0x14(%rax)      # imm = 0x200
movq -0x10(%rbp), %rax
movb $0x1, 0x11(%rax)
jmp 0x44f169
movq -0x38(%rbp), %rax
movw $0x200, 0x14(%rax)      # imm = 0x200
cmpq $0x0, -0x70(%rbp)
je 0x44f214
movq -0x50(%rbp), %rax
cmpl $0x2, 0x14(%rax)
jne 0x44f214
movl $0x0, -0xac(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xac(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
callq 0x450160
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
je 0x44f212
movl $0x0, -0xbc(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x40, %rdi
movl -0xbc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
callq 0x450160
movq %rax, -0xc8(%rbp)
cmpq $0x0, %rax
je 0x44f20d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq -0xc8(%rbp), %rcx
callq 0x4501e0
jmp 0x44f1c1
jmp 0x44f18c
jmp 0x44f214
cmpq $0x0, -0x68(%rbp)
je 0x44f60e
movl $0x0, -0xcc(%rbp)
movl $0xffffffff, -0xd0(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xd4(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xd8(%rbp)
movl $0x0, -0xd8(%rbp)
xorl %eax, %eax
cmpl $0x2, -0xd8(%rbp)
movb %al, -0x10e(%rbp)
jge 0x44f274
cmpl $0x0, -0xcc(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x10e(%rbp)
movb -0x10e(%rbp), %al
testb $0x1, %al
jne 0x44f283
jmp 0x44f498
movq $0x0, -0xe0(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x44f350
movq -0x58(%rbp), %rax
movzwl 0x12(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x12(%rax)
movq -0x58(%rbp), %rax
movl 0x1c(%rax), %eax
cmpl -0xd4(%rbp), %eax
jne 0x44f2d1
jmp 0x44f336
movq -0x68(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x20(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
movq -0x58(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x44e910
movq %rax, %rcx
movq -0x118(%rbp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x44f308
jmp 0x44f336
movq -0x58(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0xd0(%rbp)
movq -0x58(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0xd4(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0xe0(%rbp)
jmp 0x44f350
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
jmp 0x44f2a7
cmpl $0x0, -0x44(%rbp)
jge 0x44f35b
jmp 0x44f498
movl $0x1, -0xcc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x44(%rbp)
movb %al, -0x119(%rbp)
jl 0x44f383
cmpl $0x0, -0xcc(%rbp)
setne %al
movb %al, -0x119(%rbp)
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0x44f392
jmp 0x44f482
movq -0x58(%rbp), %rax
movl 0x1c(%rax), %eax
cmpl -0xd4(%rbp), %eax
je 0x44f3b5
movq -0x58(%rbp), %rax
movzwl 0x12(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x12(%rax)
jmp 0x44f466
movq -0x58(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0xd0(%rbp), %eax
jne 0x44f3f2
cmpl $-0x2, -0xd0(%rbp)
jne 0x44f3fe
movq -0x28(%rbp), %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
movq -0xe0(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x42fc30
cmpl $0x0, %eax
je 0x44f3fe
movl $0x0, -0xcc(%rbp)
jmp 0x44f464
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x42f230
movsbl %al, %eax
movl %eax, -0xe8(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x42f230
movsbl %al, %eax
movl %eax, -0xe4(%rbp)
cmpl $0x0, -0xe8(%rbp)
je 0x44f453
movl -0xe8(%rbp), %eax
cmpl -0xe4(%rbp), %eax
je 0x44f453
movl $0x0, -0xcc(%rbp)
jmp 0x44f462
movq -0x58(%rbp), %rax
movzwl 0x12(%rax), %ecx
orl $0x40, %ecx
movw %cx, 0x12(%rax)
jmp 0x44f464
jmp 0x44f466
jmp 0x44f468
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
jmp 0x44f365
jmp 0x44f484
movl -0xd8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd8(%rbp)
jmp 0x44f251
cmpl $0x0, -0xcc(%rbp)
je 0x44f60c
movq $0x0, -0xf8(%rbp)
movq $0x0, -0x100(%rbp)
movq -0x50(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x44f553
movq -0x58(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x44f4ec
jmp 0x44f53c
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
xorl %edx, %edx
callq 0x42dee0
movq %rax, -0xf0(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
callq 0x41d3c0
movq %rax, -0xf8(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x100(%rbp)
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
jmp 0x44f4d4
movq -0x30(%rbp), %rdi
movq -0x100(%rbp), %rsi
xorl %edx, %edx
callq 0x42dee0
movq %rax, -0xf0(%rbp)
movq -0x28(%rbp), %rdi
movq -0xf0(%rbp), %rdx
movl $0x31, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x418540
movq %rax, -0x108(%rbp)
cmpq $0x0, -0x108(%rbp)
je 0x44f5fa
movq -0x108(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x44ed50
movq -0xf8(%rbp), %rcx
movq -0x108(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x108(%rbp), %rsi
movl $0x3, %edx
callq 0x44d460
movl %eax, -0x10c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x10c(%rbp), %edx
callq 0x44d630
movq -0x10(%rbp), %rdi
movl -0x10c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x44eae0
jmp 0x44f60a
movq -0x30(%rbp), %rdi
movq -0xf8(%rbp), %rsi
callq 0x40c6a0
jmp 0x44f60c
jmp 0x44f60e
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)