// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowCodeStep
SQLITE_PRIVATE void sqlite3WindowCodeStep(
  Parse *pParse,                  /* Parse context */
  Select *p,                      /* Rewritten SELECT statement */
  WhereInfo *pWInfo,              /* Context returned by sqlite3WhereBegin() */
  int regGosub,                   /* Register for OP_Gosub */
  int addrGosub                   /* OP_Gosub here to return each row */
){
  Window *pMWin = p->pWin;
  ExprList *pOrderBy = pMWin->pOrderBy;
  Vdbe *v = sqlite3GetVdbe(pParse);
  int csrWrite;                   /* Cursor used to write to eph. table */
  int csrInput = p->pSrc->a[0].iCursor;     /* Cursor of sub-select */
  int nInput = p->pSrc->a[0].pTab->nCol;    /* Number of cols returned by sub */
  int iInput;                               /* To iterate through sub cols */
  int addrNe;                     /* Address of OP_Ne */
  int addrGosubFlush = 0;         /* Address of OP_Gosub to flush: */
  int addrInteger = 0;            /* Address of OP_Integer */
  int addrEmpty;                  /* Address of OP_Rewind in flush: */
  int regNew;                     /* Array of registers holding new input row */
  int regRecord;                  /* regNew array in record form */
  int regRowid;                   /* Rowid for regRecord in eph table */
  int regNewPeer = 0;             /* Peer values for new row (part of regNew) */
  int regPeer = 0;                /* Peer values for current row */
  int regFlushPart = 0;           /* Register for "Gosub flush_partition" */
  WindowCodeArg s;                /* Context object for sub-routines */
  int lblWhereEnd;                /* Label just before sqlite3WhereEnd() code */
  int regStart = 0;               /* Value of <expr> PRECEDING */
  int regEnd = 0;                 /* Value of <expr> FOLLOWING */

  assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_CURRENT
       || pMWin->eStart==TK_FOLLOWING || pMWin->eStart==TK_UNBOUNDED
  );
  assert( pMWin->eEnd==TK_FOLLOWING || pMWin->eEnd==TK_CURRENT
       || pMWin->eEnd==TK_UNBOUNDED || pMWin->eEnd==TK_PRECEDING
  );
  assert( pMWin->eExclude==0 || pMWin->eExclude==TK_CURRENT
       || pMWin->eExclude==TK_GROUP || pMWin->eExclude==TK_TIES
       || pMWin->eExclude==TK_NO
  );

  lblWhereEnd = sqlite3VdbeMakeLabel(pParse);

  /* Fill in the context object */
  memset(&s, 0, sizeof(WindowCodeArg));
  s.pParse = pParse;
  s.pMWin = pMWin;
  s.pVdbe = v;
  s.regGosub = regGosub;
  s.addrGosub = addrGosub;
  s.current.csr = pMWin->iEphCsr;
  csrWrite = s.current.csr+1;
  s.start.csr = s.current.csr+2;
  s.end.csr = s.current.csr+3;

  /* Figure out when rows may be deleted from the ephemeral table. There
  ** are four options - they may never be deleted (eDelete==0), they may
  ** be deleted as soon as they are no longer part of the window frame
  ** (eDelete==WINDOW_AGGINVERSE), they may be deleted as after the row
  ** has been returned to the caller (WINDOW_RETURN_ROW), or they may
  ** be deleted after they enter the frame (WINDOW_AGGSTEP). */
  switch( pMWin->eStart ){
    case TK_FOLLOWING:
      if( pMWin->eFrmType!=TK_RANGE
       && windowExprGtZero(pParse, pMWin->pStart)
      ){
        s.eDelete = WINDOW_RETURN_ROW;
      }
      break;
    case TK_UNBOUNDED:
      if( windowCacheFrame(pMWin)==0 ){
        if( pMWin->eEnd==TK_PRECEDING ){
          if( pMWin->eFrmType!=TK_RANGE
           && windowExprGtZero(pParse, pMWin->pEnd)
          ){
            s.eDelete = WINDOW_AGGSTEP;
          }
        }else{
          s.eDelete = WINDOW_RETURN_ROW;
        }
      }
      break;
    default:
      s.eDelete = WINDOW_AGGINVERSE;
      break;
  }

  /* Allocate registers for the array of values from the sub-query, the
  ** samve values in record form, and the rowid used to insert said record
  ** into the ephemeral table.  */
  regNew = pParse->nMem+1;
  pParse->nMem += nInput;
  regRecord = ++pParse->nMem;
  regRowid = ++pParse->nMem;

  /* If the window frame contains an "<expr> PRECEDING" or "<expr> FOLLOWING"
  ** clause, allocate registers to store the results of evaluating each
  ** <expr>.  */
  if( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ){
    regStart = ++pParse->nMem;
  }
  if( pMWin->eEnd==TK_PRECEDING || pMWin->eEnd==TK_FOLLOWING ){
    regEnd = ++pParse->nMem;
  }

  /* If this is not a "ROWS BETWEEN ..." frame, then allocate arrays of
  ** registers to store copies of the ORDER BY expressions (peer values)
  ** for the main loop, and for each cursor (start, current and end). */
  if( pMWin->eFrmType!=TK_ROWS ){
    int nPeer = (pOrderBy ? pOrderBy->nExpr : 0);
    regNewPeer = regNew + pMWin->nBufferCol;
    if( pMWin->pPartition ) regNewPeer += pMWin->pPartition->nExpr;
    regPeer = pParse->nMem+1;       pParse->nMem += nPeer;
    s.start.reg = pParse->nMem+1;   pParse->nMem += nPeer;
    s.current.reg = pParse->nMem+1; pParse->nMem += nPeer;
    s.end.reg = pParse->nMem+1;     pParse->nMem += nPeer;
  }

  /* Load the column values for the row returned by the sub-select
  ** into an array of registers starting at regNew. Assemble them into
  ** a record in register regRecord. */
  for(iInput=0; iInput<nInput; iInput++){
    sqlite3VdbeAddOp3(v, OP_Column, csrInput, iInput, regNew+iInput);
  }
  sqlite3VdbeAddOp3(v, OP_MakeRecord, regNew, nInput, regRecord);

  /* An input row has just been read into an array of registers starting
  ** at regNew. If the window has a PARTITION clause, this block generates
  ** VM code to check if the input row is the start of a new partition.
  ** If so, it does an OP_Gosub to an address to be filled in later. The
  ** address of the OP_Gosub is stored in local variable addrGosubFlush. */
  if( pMWin->pPartition ){
    int addr;
    ExprList *pPart = pMWin->pPartition;
    int nPart = pPart->nExpr;
    int regNewPart = regNew + pMWin->nBufferCol;
    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0);

    regFlushPart = ++pParse->nMem;
    addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart);
    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
    sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2);
    VdbeCoverageEqNe(v);
    addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart);
    VdbeComment((v, "call flush_partition"));
    sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1);
  }

  /* Insert the new row into the ephemeral table */
  sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, regRowid);
  sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, regRowid);
  addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, regRowid);
  VdbeCoverageNeverNull(v);

  /* This block is run for the first row of each partition */
  s.regArg = windowInitAccum(pParse, pMWin);

  if( regStart ){
    sqlite3ExprCode(pParse, pMWin->pStart, regStart);
    windowCheckValue(pParse, regStart, 0 + (pMWin->eFrmType==TK_RANGE?3:0));
  }
  if( regEnd ){
    sqlite3ExprCode(pParse, pMWin->pEnd, regEnd);
    windowCheckValue(pParse, regEnd, 1 + (pMWin->eFrmType==TK_RANGE?3:0));
  }

  if( pMWin->eFrmType!=TK_RANGE && pMWin->eStart==pMWin->eEnd && regStart ){
    int op = ((pMWin->eStart==TK_FOLLOWING) ? OP_Ge : OP_Le);
    int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd);
    VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound <expr> */
    VdbeCoverageNeverNullIf(v, op==OP_Le); /*   values previously checked */
    windowAggFinal(&s, 0);
    sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
    VdbeCoverageNeverTaken(v);
    windowReturnOneRow(&s);
    sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
    sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
    sqlite3VdbeJumpHere(v, addrGe);
  }
  if( pMWin->eStart==TK_FOLLOWING && pMWin->eFrmType!=TK_RANGE && regEnd ){
    assert( pMWin->eEnd==TK_FOLLOWING );
    sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart);
  }

  if( pMWin->eStart!=TK_UNBOUNDED ){
    sqlite3VdbeAddOp2(v, OP_Rewind, s.start.csr, 1);
    VdbeCoverageNeverTaken(v);
  }
  sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
  VdbeCoverageNeverTaken(v);
  sqlite3VdbeAddOp2(v, OP_Rewind, s.end.csr, 1);
  VdbeCoverageNeverTaken(v);
  if( regPeer && pOrderBy ){
    sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1);
    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1);
    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1);
    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1);
  }

  sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);

  sqlite3VdbeJumpHere(v, addrNe);

  /* Beginning of the block executed for the second and subsequent rows. */
  if( regPeer ){
    windowIfNewPeer(pParse, pOrderBy, regNewPeer, regPeer, lblWhereEnd);
  }
  if( pMWin->eStart==TK_FOLLOWING ){
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    if( pMWin->eEnd!=TK_UNBOUNDED ){
      if( pMWin->eFrmType==TK_RANGE ){
        int lbl = sqlite3VdbeMakeLabel(pParse);
        int addrNext = sqlite3VdbeCurrentAddr(v);
        windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
        sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext);
        sqlite3VdbeResolveLabel(v, lbl);
      }else{
        windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 0);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
      }
    }
  }else
  if( pMWin->eEnd==TK_PRECEDING ){
    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE);
    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0);
    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
    if( !bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
  }else{
    int addr = 0;
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    if( pMWin->eEnd!=TK_UNBOUNDED ){
      if( pMWin->eFrmType==TK_RANGE ){
        int lbl = 0;
        addr = sqlite3VdbeCurrentAddr(v);
        if( regEnd ){
          lbl = sqlite3VdbeMakeLabel(pParse);
          windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
        }
        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
        if( regEnd ){
          sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
          sqlite3VdbeResolveLabel(v, lbl);
        }
      }else{
        if( regEnd ){
          addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
          VdbeCoverage(v);
        }
        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
        if( regEnd ) sqlite3VdbeJumpHere(v, addr);
      }
    }
  }

  /* End of the main input loop */
  sqlite3VdbeResolveLabel(v, lblWhereEnd);
  sqlite3WhereEnd(pWInfo);

  /* Fall through */
  if( pMWin->pPartition ){
    addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
    sqlite3VdbeJumpHere(v, addrGosubFlush);
  }

  addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite);
  VdbeCoverage(v);
  if( pMWin->eEnd==TK_PRECEDING ){
    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE);
    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0);
    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
  }else if( pMWin->eStart==TK_FOLLOWING ){
    int addrStart;
    int addrBreak1;
    int addrBreak2;
    int addrBreak3;
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    if( pMWin->eFrmType==TK_RANGE ){
      addrStart = sqlite3VdbeCurrentAddr(v);
      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1);
      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
    }else
    if( pMWin->eEnd==TK_UNBOUNDED ){
      addrStart = sqlite3VdbeCurrentAddr(v);
      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regStart, 1);
      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, 0, 1);
    }else{
      assert( pMWin->eEnd==TK_FOLLOWING );
      addrStart = sqlite3VdbeCurrentAddr(v);
      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 1);
      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1);
    }
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
    sqlite3VdbeJumpHere(v, addrBreak2);
    addrStart = sqlite3VdbeCurrentAddr(v);
    addrBreak3 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
    sqlite3VdbeJumpHere(v, addrBreak1);
    sqlite3VdbeJumpHere(v, addrBreak3);
  }else{
    int addrBreak;
    int addrStart;
    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
    addrStart = sqlite3VdbeCurrentAddr(v);
    addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
    windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
    sqlite3VdbeJumpHere(v, addrBreak);
  }
  sqlite3VdbeJumpHere(v, addrEmpty);

  sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
  if( pMWin->pPartition ){
    if( pMWin->regStartRowid ){
      sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
    }
    sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v));
    sqlite3VdbeAddOp1(v, OP_Return, regFlushPart);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r8d, 0x20(%rsp)
movl %ecx, %r12d
movq %rdx, 0xb0(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movq 0x70(%rsi), %rbx
movq 0x18(%rbx), %rax
movq %rax, 0x58(%rsp)
callq 0x2bc630
movq %rax, %r14
movq 0x28(%r13), %rax
movl 0x48(%rax), %r13d
movq 0x28(%rax), %rax
movswl 0x46(%rax), %ebp
movl 0x44(%r15), %eax
decl %eax
movl %eax, 0xc(%rsp)
movl %eax, 0x44(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rsp)
movups %xmm0, 0x80(%rsp)
movq %r15, 0x10(%rsp)
movq %r15, 0x60(%rsp)
movq %rbx, 0x68(%rsp)
movq %r14, 0x70(%rsp)
movl %r12d, 0x7c(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x58(%rbx), %eax
movl %eax, 0x90(%rsp)
leal 0x2(%rax), %r12d
movl %r12d, 0x88(%rsp)
movq %rax, 0x38(%rsp)
addl $0x3, %eax
movl %eax, 0x34(%rsp)
movl %eax, 0x98(%rsp)
movzbl 0x21(%rbx), %eax
cmpl $0x5a, %eax
je 0x2cf6b7
movl $0x2, %ecx
cmpl $0x56, %eax
movq 0x10(%rsp), %r15
jne 0x2cf72d
cmpb $0x59, 0x20(%rbx)
je 0x2cf734
movq 0x28(%rbx), %rsi
movq (%r15), %rdi
callq 0x2de35c
movl $0x1, %ecx
testl %eax, %eax
jne 0x2cf72d
jmp 0x2cf734
cmpl $0x0, 0x84(%rbx)
movq 0x10(%rsp), %r15
jne 0x2cf734
leaq 0x105bab(%rip), %rax    # 0x3d5277
leaq 0x105b9f(%rip), %rcx    # 0x3d5272
leaq 0x105ba1(%rip), %rdx    # 0x3d527b
leaq 0x105ba4(%rip), %rsi    # 0x3d5285
movq %rbx, %rdi
movq 0x50(%rdi), %r8
movq 0x38(%r8), %r8
cmpq %rax, %r8
je 0x2cf734
cmpq %rcx, %r8
je 0x2cf734
cmpq %rdx, %r8
je 0x2cf734
cmpq %rsi, %r8
je 0x2cf734
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
jne 0x2cf6e4
movl $0x1, %ecx
cmpb $0x58, 0x22(%rbx)
jne 0x2cf72d
cmpb $0x59, 0x20(%rbx)
je 0x2cf734
movq 0x30(%rbx), %rsi
movq (%r15), %rdi
callq 0x2de35c
movl $0x3, %ecx
jmp 0x2cf6b1
movl %ecx, 0x84(%rsp)
movl 0x38(%r15), %eax
leal (%rax,%rbp), %edi
addl $0x2, %edi
movl %edi, 0x38(%r15)
movzbl 0x21(%rbx), %edx
cmpl $0x58, %edx
je 0x2cf754
xorl %esi, %esi
movl %edi, %ecx
cmpl $0x56, %edx
jne 0x2cf760
leal (%rax,%rbp), %ecx
addl $0x3, %ecx
movl %ecx, 0x38(%r15)
movl %ecx, %esi
movl %esi, 0x8(%rsp)
movzbl 0x22(%rbx), %edx
cmpl $0x58, %edx
movl %r12d, 0xac(%rsp)
movl %edi, 0x30(%rsp)
je 0x2cf786
movl $0x0, 0x4(%rsp)
cmpl $0x56, %edx
jne 0x2cf790
incl %ecx
movl %ecx, 0x38(%r15)
movl %ecx, 0x4(%rsp)
movl %eax, %r12d
incl %r12d
xorl %r8d, %r8d
cmpb $0x4c, 0x20(%rbx)
movl $0x0, %r9d
movl $0x0, %r10d
movl $0x0, 0x1c(%rsp)
movl $0x0, %edi
je 0x2cf81a
movq 0x58(%rsp), %rdx
testq %rdx, %rdx
je 0x2cf7c6
movl (%rdx), %edx
jmp 0x2cf7c8
xorl %edx, %edx
movl 0x78(%rbx), %edi
addl %r12d, %edi
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x2cf7d9
addl (%rsi), %edi
leal 0x1(%rcx), %esi
movl %esi, 0x1c(%rsp)
leal (%rdx,%rcx), %esi
leal (%rdx,%rcx), %r10d
incl %r10d
movl %r10d, 0x8c(%rsp)
leal (%rdx,%rsi), %r9d
incl %r9d
addl %edx, %esi
movl %r9d, 0x94(%rsp)
leal (%rdx,%rsi), %r8d
incl %r8d
movl %r8d, 0x9c(%rsp)
addl %edx, %edx
addl %esi, %edx
movl %edx, 0x38(%r15)
movl %r10d, 0xa0(%rsp)
movl %r9d, 0xa4(%rsp)
movl %r8d, 0xa8(%rsp)
movl %edi, 0x40(%rsp)
addl %ebp, %eax
incl %eax
movl %eax, 0x50(%rsp)
testw %bp, %bp
jle 0x2cf865
xorl %r15d, %r15d
leal (%r12,%r15), %r8d
movq %r14, %rdi
movl $0x59, %esi
movl %r13d, %edx
movl %r15d, %ecx
callq 0x2a83e1
incl %r15d
cmpl %r15d, %ebp
jne 0x2cf846
movq 0x38(%rsp), %rax
incl %eax
movl %eax, 0x44(%rsp)
movq %r14, %rdi
movl $0x5b, %esi
movl %r12d, %edx
movl %ebp, %ecx
movl 0x50(%rsp), %r8d
callq 0x2a83e1
movq 0x10(%rbx), %rsi
xorl %ebp, %ebp
movl $0x0, 0x2c(%rsp)
movl $0x0, %r15d
testq %rsi, %rsi
movq %rbx, 0x20(%rsp)
je 0x2cf97f
movq %rbx, %r15
movl (%rsi), %ebx
addl 0x78(%r15), %r12d
movq 0x10(%rsp), %r13
movq %r13, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cde19
movq %rax, 0x48(%rsp)
movl 0x38(%r13), %eax
incl %eax
movl %eax, 0x2c(%rsp)
movl %eax, 0x38(%r13)
movl 0x6c(%r15), %ecx
movq %r14, %rdi
movl $0x56, %esi
movl %r12d, %edx
movl %ebx, %r8d
callq 0x2a83e1
movl %eax, %r15d
movq (%r14), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2cf90a
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
movq 0x48(%rsp), %rdx
callq 0x28fb69
jmp 0x2cf92b
movq 0x88(%r14), %rax
movslq 0x90(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
movb $-0x9, -0x17(%rax,%rcx,8)
movq 0x48(%rsp), %rdx
movq %rdx, -0x8(%rax,%rcx,8)
leal 0x2(%r15), %edx
addl $0x4, %r15d
movq %r14, %rdi
movl $0x10, %esi
movl %r15d, %ecx
movl %edx, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl $0xc, %esi
movl 0x2c(%rsp), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl %eax, %r15d
movq 0x20(%rsp), %rax
movl 0x6c(%rax), %ecx
decl %ebx
movq %r14, %rdi
movl $0x4d, %esi
movl %r12d, %edx
movl %ebx, %r8d
movq %rax, %rbx
callq 0x2a83e1
movl %r15d, 0x48(%rsp)
movq %r14, %rdi
movl $0x78, %esi
movl 0x44(%rsp), %r15d
movl %r15d, %edx
movl 0x30(%rsp), %r12d
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl $0x79, %esi
movl %r15d, %edx
movl 0x50(%rsp), %ecx
movl %r12d, %r8d
callq 0x2a83e1
movl 0x80(%rbx), %edx
movq %r14, 0x50(%rsp)
movq %r14, %rdi
movl $0x34, %esi
xorl %ecx, %ecx
movl %r12d, %r8d
callq 0x2a83e1
movl %eax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2bc630
movq %rax, %r12
leaq 0x105895(%rip), %r15    # 0x3d5285
movq %rbx, %r14
movl %ebp, %r13d
movq 0x50(%r14), %rbx
movl 0x5c(%r14), %ecx
xorl %ebp, %ebp
movq %r12, %rdi
movl $0x48, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2a83e1
movq 0x70(%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2cfa21
movl (%rax), %ebp
cmpl %ebp, %r13d
cmovgl %r13d, %ebp
movq 0x20(%rsp), %rax
cmpl $0x0, 0x84(%rax)
jne 0x2cfabb
movq 0x38(%rbx), %rax
leaq 0x105836(%rip), %rcx    # 0x3d527b
cmpq %rcx, %rax
setne %cl
cmpq %r15, %rax
setne %al
testb %al, %cl
jne 0x2cfa83
movl 0x68(%r14), %ecx
movq %r12, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x68(%r14), %ecx
incl %ecx
movq %r12, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2a83e1
testb $0x10, 0x5(%rbx)
je 0x2cfabb
movl 0x64(%r14), %edx
testl %edx, %edx
je 0x2cfabb
movq %r12, %rdi
movl $0x8a, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x68(%r14), %ecx
incl %ecx
movq %r12, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2a83e1
movq 0x40(%r14), %r14
testq %r14, %r14
jne 0x2cf9f3
movq 0x10(%rsp), %r14
movl 0x38(%r14), %eax
leal 0x1(%rax), %ecx
addl %eax, %ebp
movl %ebp, 0x38(%r14)
movl %ecx, 0x80(%rsp)
movl 0x8(%rsp), %r12d
testl %r12d, %r12d
movq 0x20(%rsp), %rbx
je 0x2cfb16
movq 0x28(%rbx), %rsi
movq %r14, %rdi
movl %r12d, %edx
callq 0x2bc7e9
xorl %eax, %eax
cmpb $0x59, 0x20(%rbx)
sete %al
leal (%rax,%rax,2), %edx
movq %r14, %rdi
movl %r12d, %esi
callq 0x2de3af
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
movq 0x50(%rsp), %r14
movl 0xc(%rsp), %r15d
je 0x2cfb53
movq 0x30(%rbx), %rsi
movq 0x10(%rsp), %r13
movq %r13, %rdi
movl %ebp, %edx
callq 0x2bc7e9
xorl %eax, %eax
cmpb $0x59, 0x20(%rbx)
sete %al
leal (%rax,%rax,2), %edx
incl %edx
movq %r13, %rdi
movl %ebp, %esi
callq 0x2de3af
cmpb $0x59, 0x20(%rbx)
movl 0x1c(%rsp), %r13d
je 0x2cfc36
movb 0x21(%rbx), %al
testl %r12d, %r12d
je 0x2cfc39
cmpb 0x22(%rbx), %al
jne 0x2cfc39
xorl %ecx, %ecx
cmpb $0x56, %al
sete %cl
leal 0x37(,%rcx,2), %esi
movq %r14, %rdi
movl %r12d, %edx
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x2a83e1
movl %eax, %ebp
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2de55c
movq %r14, %rdi
movl $0x25, %esi
movq 0x38(%rsp), %r15
movl %r15d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
leaq 0x60(%rsp), %rdi
callq 0x2de730
movq %r14, %rdi
movl $0x8a, %esi
movl %r15d, %edx
movl 0xc(%rsp), %r15d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x90(%r14), %eax
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2cfc15
leaq 0x1ef275(%rip), %rcx    # 0x4bee88
jmp 0x2cfc2f
leal -0x1(%rax), %ecx
testl %ebp, %ebp
cmovnsl %ebp, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%r14), %rcx
movl %eax, 0x8(%rcx)
movl 0x4(%rsp), %ebp
movb 0x21(%rbx), %al
cmpb $0x56, %al
jne 0x2cfc5f
testl %ebp, %ebp
je 0x2cfc63
cmpb $0x59, 0x20(%rbx)
je 0x2cfc63
movq %r14, %rdi
movl $0x6a, %esi
movl %r12d, %edx
movl %ebp, %ecx
movl %r12d, %r8d
callq 0x2a83e1
movb 0x21(%rbx), %al
cmpb $0x5a, %al
je 0x2cfc7f
movq %r14, %rdi
movl $0x25, %esi
movl 0xac(%rsp), %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl $0x25, %esi
movq 0x38(%rsp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl $0x25, %esi
movl 0x34(%rsp), %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
testl %r13d, %r13d
setne %al
cmpq $0x0, 0x58(%rsp)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2cfd4e
movq 0x58(%rsp), %r13
movl (%r13), %r8d
decl %r8d
movq %r14, %rdi
movl $0x4d, %esi
movl 0x40(%rsp), %edx
movl 0x1c(%rsp), %ecx
callq 0x2a83e1
movl (%r13), %r8d
decl %r8d
movq %r14, %rdi
movl $0x4d, %esi
movl 0x1c(%rsp), %edx
movl 0xa0(%rsp), %ecx
callq 0x2a83e1
movl (%r13), %r8d
decl %r8d
movq %r14, %rdi
movl $0x4d, %esi
movl 0x1c(%rsp), %edx
movl 0xa4(%rsp), %ecx
callq 0x2a83e1
movl (%r13), %r8d
movl 0x1c(%rsp), %r13d
decl %r8d
movq %r14, %rdi
movl $0x4d, %esi
movl %r13d, %edx
movl 0xa8(%rsp), %ecx
callq 0x2a83e1
movq %r14, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x90(%r14), %eax
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2cfd7c
leaq 0x1ef10e(%rip), %rcx    # 0x4bee88
jmp 0x2cfd9a
leal -0x1(%rax), %ecx
movl 0x30(%rsp), %edx
testl %edx, %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%r14), %rcx
movl %eax, 0x8(%rcx)
testl %r13d, %r13d
movq 0x58(%rsp), %rsi
je 0x2cfdbb
movq 0x10(%rsp), %rdi
movl 0x40(%rsp), %edx
movl %r13d, %ecx
movl %r15d, %r8d
callq 0x2def1c
movb 0x21(%rbx), %al
cmpb $0x56, %al
jne 0x2cfe6c
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
cmpb $0x5a, 0x22(%rbx)
je 0x2cff9c
cmpb $0x59, 0x20(%rbx)
jne 0x2cff36
movq 0x10(%rsp), %rax
movl 0x44(%rax), %ebp
decl %ebp
movl %ebp, 0x44(%rax)
movl 0x90(%r14), %r15d
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movl $0x39, %esi
movq 0x38(%rsp), %rdx
movl 0x4(%rsp), %ecx
movl 0x34(%rsp), %r8d
movl %ebp, %r9d
callq 0x2df44f
movq %r12, %rdi
movl $0x2, %esi
movl 0x8(%rsp), %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r12, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r14, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl %ebp, %esi
callq 0x2bfa39
jmp 0x2cff97
cmpb $0x58, 0x22(%rbx)
jne 0x2cfec9
cmpb $0x58, %al
jne 0x2cff5c
movq 0x20(%rsp), %rax
movb 0x20(%rax), %bl
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2deff8
cmpb $0x59, %bl
movq 0x20(%rsp), %rbx
jne 0x2cff6f
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl $0x2, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
jmp 0x2cff90
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
cmpb $0x5a, 0x22(%rbx)
je 0x2cff9c
cmpb $0x59, 0x20(%rbx)
jne 0x2d0208
movl 0x90(%r14), %r12d
movl 0x4(%rsp), %r13d
testl %r13d, %r13d
je 0x2d0427
movq 0x10(%rsp), %rax
movl 0x44(%rax), %ebp
decl %ebp
movl %ebp, 0x44(%rax)
leaq 0x60(%rsp), %rdi
movl $0x39, %esi
movq 0x38(%rsp), %rdx
movl %r13d, %ecx
movl 0x34(%rsp), %r8d
movl %ebp, %r9d
callq 0x2df44f
jmp 0x2d0429
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
movl 0x4(%rsp), %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r15, %rdi
movl $0x2, %esi
movl 0x8(%rsp), %edx
jmp 0x2cff90
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2deff8
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r15, %rdi
movl $0x2, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2deff8
movl 0xc(%rsp), %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x2bfa39
movq 0xb0(%rsp), %rdi
callq 0x2d11fa
cmpq $0x0, 0x10(%rbx)
je 0x2cffed
movq %r14, %rdi
movl $0x45, %esi
xorl %edx, %edx
movl 0x2c(%rsp), %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl %eax, %r13d
movl 0x90(%r14), %eax
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2cfffb
leaq 0x1eee9d(%rip), %rcx    # 0x4bee88
jmp 0x2d0019
xorl %r13d, %r13d
movl 0x8(%rsp), %r12d
movl 0x4(%rsp), %ebp
jmp 0x2d0025
leal -0x1(%rax), %ecx
movl 0x48(%rsp), %edx
testl %edx, %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%r14), %rcx
movl 0x8(%rsp), %r12d
movl 0x4(%rsp), %ebp
movl %eax, 0x8(%rcx)
movq %r14, %rdi
movl $0x25, %esi
movl 0x44(%rsp), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl %eax, %r15d
movq %rbx, %rax
movb 0x21(%rbx), %bl
cmpb $0x58, 0x22(%rax)
jne 0x2d0086
cmpb $0x58, %bl
jne 0x2d00f5
movq 0x20(%rsp), %rax
movb 0x20(%rax), %bl
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2deff8
cmpb $0x59, %bl
jne 0x2d0108
leaq 0x60(%rsp), %rdi
movl $0x2, %esi
movl %r12d, %edx
jmp 0x2d0101
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
cmpb $0x56, %bl
jne 0x2d0132
movl %r13d, 0x10(%rsp)
movq 0x20(%rsp), %rbx
cmpb $0x59, 0x20(%rbx)
jne 0x2d01a4
movl 0x90(%r14), %r13d
movl %r12d, %edx
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movl $0x2, %esi
movl $0x1, %ecx
callq 0x2deff8
movl %eax, %ebp
movq %r12, %rdi
movl $0x1, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2deff8
movl %eax, %r12d
jmp 0x2d0268
leaq 0x60(%rsp), %rdi
movl $0x3, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2deff8
leaq 0x60(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
movl 0x90(%r14), %eax
movq (%r14), %rcx
movb 0x61(%rcx), %cl
movq 0x20(%rsp), %rbx
jmp 0x2d0335
movl %r15d, 0x10(%rsp)
movl %r13d, %r15d
movl %r12d, %ebx
movl 0x90(%r14), %r12d
leaq 0x60(%rsp), %r13
movq %r13, %rdi
movl $0x1, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2deff8
movl %eax, %ebp
movq %r13, %rdi
movl $0x2, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r14, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x90(%r14), %eax
movq (%r14), %rcx
movb 0x61(%rcx), %cl
testb %cl, %cl
movq 0x20(%rsp), %rbx
je 0x2d01de
leaq 0x1eece6(%rip), %rdx    # 0x4bee88
jmp 0x2d01f8
cmpb $0x5a, 0x22(%rbx)
movl 0x90(%r14), %r13d
jne 0x2d0235
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movl $0x1, %esi
movl %r12d, %edx
movl $0x1, %ecx
callq 0x2deff8
movl %eax, %r12d
movq %rbp, %rdi
movl $0x2, %esi
xorl %edx, %edx
jmp 0x2d025c
leal -0x1(%rax), %edx
testl %ebp, %ebp
cmovnsl %ebp, %edx
movslq %edx, %rdx
leaq (%rdx,%rdx,2), %rdx
shlq $0x3, %rdx
addq 0x88(%r14), %rdx
movl %eax, 0x8(%rdx)
movl %r15d, %r13d
movl 0x10(%rsp), %r15d
jmp 0x2d0335
movl 0x4(%rsp), %ebp
testl %ebp, %ebp
je 0x2d0484
movq %r14, %rdi
movl $0x30, %esi
movl %ebp, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2a83e1
movl %ebp, %r13d
movl %eax, %ebp
jmp 0x2d0489
movl %ebp, %edx
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movl $0x1, %esi
movl $0x1, %ecx
callq 0x2deff8
movl %r12d, %edx
movl %eax, %r12d
movq %rbp, %rdi
movl $0x2, %esi
movl $0x1, %ecx
callq 0x2deff8
movl %eax, %ebp
movq %r14, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x90(%r14), %r13d
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
je 0x2d0296
leaq 0x1eebf4(%rip), %rax    # 0x4bee88
jmp 0x2d02b0
leal -0x1(%r13), %eax
testl %ebp, %ebp
cmovnsl %ebp, %eax
cltq
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x88(%r14), %rax
movl %r13d, 0x8(%rax)
leaq 0x60(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2deff8
movl %eax, %ebp
movq %r14, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r13d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x90(%r14), %eax
movq (%r14), %rcx
movb 0x61(%rcx), %cl
testb %cl, %cl
je 0x2d0301
movl %eax, 0x1eeb98(%rip)    # 0x4bee90
leaq 0x1eeb89(%rip), %rdx    # 0x4bee88
jmp 0x2d032d
leal -0x1(%rax), %edx
testl %r12d, %r12d
cmovsl %edx, %r12d
movq 0x88(%r14), %rsi
movslq %r12d, %rdi
leaq (%rdi,%rdi,2), %rdi
testl %ebp, %ebp
cmovsl %edx, %ebp
movl %eax, 0x8(%rsi,%rdi,8)
movslq %ebp, %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rsi,%rdx,8), %rdx
movl 0x10(%rsp), %r13d
movl %eax, 0x8(%rdx)
testb %cl, %cl
je 0x2d0342
leaq 0x1eeb48(%rip), %rcx    # 0x4bee88
jmp 0x2d035e
leal -0x1(%rax), %ecx
testl %r15d, %r15d
cmovnsl %r15d, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%r14), %rcx
movl %eax, 0x8(%rcx)
movq %r14, %rdi
movl $0x8a, %esi
movq 0x38(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
cmpq $0x0, 0x10(%rbx)
je 0x2d03cf
movl 0x84(%rbx), %ecx
testl %ecx, %ecx
je 0x2d03b6
movq %r14, %rdi
movl $0x45, %esi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x88(%rbx), %ecx
movq %r14, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2a83e1
movl 0x90(%r14), %eax
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d03e1
leaq 0x1eeabb(%rip), %rcx    # 0x4bee88
jmp 0x2d03fd
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal -0x1(%rax), %ecx
testl %r13d, %r13d
cmovnsl %r13d, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%r14), %rcx
movl %eax, 0x4(%rcx)
movq %r14, %rdi
movl $0x41, %esi
movl 0x2c(%rsp), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a83e1
xorl %ebp, %ebp
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r15, %rdi
movl $0x2, %esi
movl 0x8(%rsp), %edx
xorl %ecx, %ecx
callq 0x2deff8
testl %r13d, %r13d
movl 0xc(%rsp), %r15d
je 0x2cff9c
movq %r14, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2a83e1
movq %r14, %rdi
movl %ebp, %esi
callq 0x2bfa39
jmp 0x2cff9c
movl %ebp, %r13d
xorl %ebp, %ebp
movl 0x8(%rsp), %r12d
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2deff8
movq %r15, %rdi
movl $0x2, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2deff8
testl %r13d, %r13d
movl 0xc(%rsp), %r15d
je 0x2cff9c
movl 0x90(%r14), %eax
movq (%r14), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d04dd
leaq 0x1ee9ad(%rip), %rcx    # 0x4bee88
jmp 0x2d04f7
leal -0x1(%rax), %ecx
testl %ebp, %ebp
cmovnsl %ebp, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%r14), %rcx
movl %eax, 0x8(%rcx)
jmp 0x2cff9c