// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/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;
  whereClauseInit(pOrWc, pWInfo);
  whereSplit(pOrWc, pExpr, TK_OR);
  exprAnalyzeAll(pSrc, pOrWc);
  if( db->mallocFailed ) return;
  assert( pOrWc->nTerm>=2 );

  /*
  ** Compute the set of tables that might satisfy cases 1 or 2.
  */
  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 = sqlite3DbMallocRaw(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;
        whereClauseInit(pAndWC, pWC->pWInfo);
        whereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
        exprAnalyzeAll(pSrc, pAndWC);
        pAndWC->pOuter = pWC;
        testcase( db->mallocFailed );
        if( !db->mallocFailed ){
          for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
            assert( pAndTerm->pExpr );
            if( allowedOp(pAndTerm->pExpr->op) ){
              b |= getMask(&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 = getMask(&pWInfo->sMaskSet, pOrTerm->leftCursor);
      if( pOrTerm->wtFlags & TERM_VIRTUAL ){
        WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent];
        b |= getMask(&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 2.  The set might be
  ** empty.
  */
  pOrInfo->indexable = indexable;
  pTerm->eOperator = indexable==0 ? 0 : WO_OR;

  /*
  ** 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++){
      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 & getMask(&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 preceeded
          ** 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;
        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==getMask(&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 ){
          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, 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];
        pWC->a[idxNew].iParent = idxTerm;
        pTerm->nChild = 1;
      }else{
        sqlite3ExprListDelete(db, pList);
      }
      pTerm->eOperator = WO_NOOP;  /* case 1 trumps case 2 */
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
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
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1f0, %esi            # imm = 0x1F0
callq 0x11ca0
movq %rax, %rcx
movq %rcx, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x60(%rbp)
jne 0x76522
jmp 0x76c0d
movq -0x38(%rbp), %rax
movzbl 0x1a(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x1a(%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x71c10
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x44, %edx
callq 0x71cd0
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x71da0
movq -0x30(%rbp), %rax
cmpb $0x0, 0x50(%rax)
je 0x76573
jmp 0x76c0d
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, -0xe5(%rbp)
jl 0x765b8
cmpq $0x0, -0x70(%rbp)
setne %al
movb %al, -0xe5(%rbp)
movb -0xe5(%rbp), %al
testb $0x1, %al
jne 0x765c7
jmp 0x767ff
movq -0x58(%rbp), %rax
movzwl 0x18(%rax), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x76724
movq $0x0, -0x68(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1e8, %esi            # imm = 0x1E8
callq 0x134e0
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x7671f
movq $0x0, -0x98(%rbp)
movq -0x78(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x58(%rbp), %rax
movzbl 0x1a(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x1a(%rax)
movq -0x58(%rbp), %rax
movw $0x200, 0x18(%rax)      # imm = 0x200
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x71c10
movq -0x80(%rbp), %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rsi
movl $0x45, %edx
callq 0x71cd0
movq -0x8(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x71da0
movq -0x10(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpb $0x0, 0x50(%rax)
jne 0x76710
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 0x7670e
movq -0x88(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %edi
callq 0x762f0
cmpl $0x0, %eax
je 0x766e9
movq -0x20(%rbp), %rdi
addq $0x4c, %rdi
movq -0x88(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x72c50
orq -0x98(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x766eb
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
movq -0x88(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x88(%rbp)
jmp 0x7669e
jmp 0x76710
movq -0x98(%rbp), %rax
andq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x767e3
movq -0x58(%rbp), %rax
movzbl 0x1a(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x76739
jmp 0x767e1
movq -0x20(%rbp), %rdi
addq $0x4c, %rdi
movq -0x58(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x72c50
movq %rax, -0xa0(%rbp)
movq -0x58(%rbp), %rax
movzbl 0x1a(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x767a7
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x58(%rbp), %rcx
movslq 0x8(%rcx), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4c, %rdi
movq -0xa8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x72c50
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 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x767d0
movq $0x0, -0x68(%rbp)
jmp 0x767df
movq -0xa0(%rbp), %rax
andq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x767e1
jmp 0x767e3
jmp 0x767e5
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x58(%rbp)
jmp 0x7659c
movq -0x70(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x1e8(%rax)
movq -0x70(%rbp), %rdx
movl $0x100, %eax            # imm = 0x100
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
movw %ax, %cx
movq -0x38(%rbp), %rax
movw %cx, 0x18(%rax)
cmpq $0x0, -0x68(%rbp)
je 0x76c0d
movl $0x0, -0xac(%rbp)
movl $0xffffffff, -0xb0(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xb4(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xb8(%rbp)
movl $0x0, -0xb8(%rbp)
xorl %eax, %eax
cmpl $0x2, -0xb8(%rbp)
movb %al, -0xe6(%rbp)
jge 0x7688b
cmpl $0x0, -0xac(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0xe6(%rbp)
movb -0xe6(%rbp), %al
testb $0x1, %al
jne 0x7689a
jmp 0x76a5e
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 0x76946
movq -0x58(%rbp), %rax
movzbl 0x1a(%rax), %ecx
andl $-0x41, %ecx
movb %cl, 0x1a(%rax)
movq -0x58(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xb4(%rbp), %eax
jne 0x768dc
jmp 0x7692c
movq -0x68(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4c, %rdi
movq -0x58(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x72c50
movq %rax, %rcx
movq -0xf0(%rbp), %rax
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x76910
jmp 0x7692c
movq -0x58(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xb0(%rbp)
movq -0x58(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xb4(%rbp)
jmp 0x76946
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x58(%rbp)
jmp 0x768b3
cmpl $0x0, -0x44(%rbp)
jge 0x76951
jmp 0x76a5e
movl $0x1, -0xac(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x44(%rbp)
movb %al, -0xf1(%rbp)
jl 0x76979
cmpl $0x0, -0xac(%rbp)
setne %al
movb %al, -0xf1(%rbp)
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x76988
jmp 0x76a48
movq -0x58(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xb4(%rbp), %eax
je 0x769aa
movq -0x58(%rbp), %rax
movzbl 0x1a(%rax), %ecx
andl $-0x41, %ecx
movb %cl, 0x1a(%rax)
jmp 0x76a2c
movq -0x58(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xb0(%rbp), %eax
je 0x769c5
movl $0x0, -0xac(%rbp)
jmp 0x76a2a
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x658e0
movsbl %al, %eax
movl %eax, -0xc0(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x658e0
movsbl %al, %eax
movl %eax, -0xbc(%rbp)
cmpl $0x0, -0xc0(%rbp)
je 0x76a1a
movl -0xc0(%rbp), %eax
cmpl -0xbc(%rbp), %eax
je 0x76a1a
movl $0x0, -0xac(%rbp)
jmp 0x76a28
movq -0x58(%rbp), %rax
movzbl 0x1a(%rax), %ecx
orl $0x40, %ecx
movb %cl, 0x1a(%rax)
jmp 0x76a2a
jmp 0x76a2c
jmp 0x76a2e
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x58(%rbp)
jmp 0x7695b
jmp 0x76a4a
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0x76868
cmpl $0x0, -0xac(%rbp)
je 0x76c0b
movq $0x0, -0xd0(%rbp)
movq $0x0, -0xd8(%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 0x76b19
movq -0x58(%rbp), %rax
movzbl 0x1a(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x76ab2
jmp 0x76b02
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x54650
movq %rax, -0xd0(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0xd8(%rbp)
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x58(%rbp)
jmp 0x76a9a
movq -0x30(%rbp), %rdi
movq -0xd8(%rbp), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rdi
movq -0xc8(%rbp), %rdx
movl $0x48, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x508b0
movq %rax, -0xe0(%rbp)
cmpq $0x0, -0xe0(%rbp)
je 0x76bf1
movq -0xe0(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x76460
movq -0xd0(%rbp), %rcx
movq -0xe0(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movl $0x3, %edx
callq 0x754e0
movl %eax, -0xe4(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0xe4(%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, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xe4(%rbp), %rdx
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
movb $0x1, 0x1b(%rax)
jmp 0x76c01
movq -0x30(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x47460
movq -0x38(%rbp), %rax
movw $0x800, 0x18(%rax)      # imm = 0x800
jmp 0x76c0d
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)