// File: /workspace/github_c_makefile_star2_O1/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, %r14d
movl %ecx, %r12d
movq %rdx, 0xb0(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq 0x70(%rsi), %rbp
movq 0x18(%rbp), %rax
movq %rax, 0xa8(%rsp)
callq 0x2c5ddf
movq 0x28(%r15), %rcx
movl 0x48(%rcx), %r15d
movq 0x28(%rcx), %rcx
movswl 0x46(%rcx), %r13d
movl 0x44(%rbx), %ecx
decl %ecx
movl %ecx, 0x48(%rsp)
movl %ecx, 0x44(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movq %rbx, 0x10(%rsp)
movq %rbx, 0x50(%rsp)
movq %rax, %rbx
movq %rbp, 0x58(%rsp)
movq %rax, 0x60(%rsp)
movl %r12d, 0x6c(%rsp)
movl %r14d, 0x68(%rsp)
movl 0x58(%rbp), %eax
movl %eax, 0x80(%rsp)
leal 0x2(%rax), %ecx
movl %ecx, 0xa4(%rsp)
movl %ecx, 0x78(%rsp)
movq %rax, 0x38(%rsp)
addl $0x3, %eax
movl %eax, 0x34(%rsp)
movl %eax, 0x88(%rsp)
movzbl 0x21(%rbp), %eax
cmpl $0x5a, %eax
je 0x2d8f21
movl $0x2, %ecx
cmpl $0x56, %eax
movq 0x10(%rsp), %r14
jne 0x2d8f9f
cmpb $0x59, 0x20(%rbp)
je 0x2d8fa3
movq 0x28(%rbp), %rsi
movq %r14, %rdi
callq 0x2e760f
movl $0x1, %ecx
testl %eax, %eax
jne 0x2d8f9f
jmp 0x2d8fa3
cmpl $0x0, 0x84(%rbp)
movq 0x10(%rsp), %r14
jne 0x2d8fa3
testq %rbp, %rbp
je 0x2d8f78
leaq 0x105abc(%rip), %rax    # 0x3de9f7
leaq 0x105ab0(%rip), %rcx    # 0x3de9f2
leaq 0x105ab2(%rip), %rdx    # 0x3de9fb
leaq 0x105ab5(%rip), %rsi    # 0x3dea05
movq %rbp, %rdi
movq 0x50(%rdi), %r8
movq 0x38(%r8), %r8
cmpq %rax, %r8
je 0x2d8fa3
cmpq %rcx, %r8
je 0x2d8fa3
cmpq %rdx, %r8
je 0x2d8fa3
cmpq %rsi, %r8
je 0x2d8fa3
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
jne 0x2d8f53
movl $0x1, %ecx
cmpb $0x58, 0x22(%rbp)
jne 0x2d8f9f
cmpb $0x59, 0x20(%rbp)
je 0x2d8fa3
movq 0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x2e760f
movl $0x3, %ecx
jmp 0x2d8f14
movl %ecx, 0x74(%rsp)
movl 0x38(%r14), %eax
leal (%rax,%r13), %ecx
addl $0x2, %ecx
movl %ecx, 0x30(%rsp)
movl %ecx, 0x38(%r14)
movzbl 0x21(%rbp), %ecx
cmpl $0x58, %ecx
je 0x2d8fc6
xorl %edx, %edx
cmpl $0x56, %ecx
jne 0x2d8fd1
leal (%rax,%r13), %edx
addl $0x3, %edx
movl %edx, 0x38(%r14)
movl %edx, 0xc(%rsp)
movzbl 0x22(%rbp), %ecx
cmpl $0x58, %ecx
je 0x2d8feb
movl $0x0, 0x8(%rsp)
cmpl $0x56, %ecx
jne 0x2d8ff9
movl 0x38(%r14), %ecx
incl %ecx
movl %ecx, 0x8(%rsp)
movl %ecx, 0x38(%r14)
movl %eax, %r12d
incl %r12d
xorl %r8d, %r8d
cmpb $0x4c, 0x20(%rbp)
movl $0x0, %edi
je 0x2d9072
movq 0xa8(%rsp), %rcx
testq %rcx, %rcx
je 0x2d901e
movl (%rcx), %ecx
jmp 0x2d9020
xorl %ecx, %ecx
movl 0x78(%rbp), %edi
addl %r12d, %edi
movq 0x10(%rbp), %rdx
testq %rdx, %rdx
je 0x2d9031
addl (%rdx), %edi
movl 0x38(%r14), %edx
leal 0x1(%rdx), %r8d
leal (%rdx,%rcx), %esi
movl %esi, 0x38(%r14)
addl %ecx, %edx
incl %edx
movl %edx, 0x7c(%rsp)
leal (%rsi,%rcx), %edx
movl %edx, 0x38(%r14)
leal 0x1(%rcx,%rsi), %esi
movl %esi, 0x84(%rsp)
leal (%rdx,%rcx), %esi
movl %esi, 0x38(%r14)
addl %ecx, %edx
incl %edx
movl %edx, 0x8c(%rsp)
addl %ecx, %esi
movl %esi, 0x38(%r14)
movl %r8d, 0x1c(%rsp)
movl %edi, 0x44(%rsp)
addl %r13d, %eax
incl %eax
movl %eax, 0x20(%rsp)
testw %r13w, %r13w
jle 0x2d90ac
xorl %r14d, %r14d
leal (%r12,%r14), %r8d
movq %rbx, %rdi
movl $0x59, %esi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x2b200c
incl %r14d
cmpl %r14d, %r13d
jne 0x2d908d
movq 0x38(%rsp), %rax
incl %eax
movl %eax, 0x4c(%rsp)
movq %rbx, %rdi
movl $0x5b, %esi
movl %r12d, %edx
movl %r13d, %ecx
movl 0x20(%rsp), %r8d
callq 0x2b200c
movq 0x10(%rbp), %rsi
xorl %r13d, %r13d
movl $0x0, 0x2c(%rsp)
movl $0x0, %r14d
testq %rsi, %rsi
je 0x2d91c6
movl (%rsi), %r15d
addl 0x78(%rbp), %r12d
movq %rbx, %r14
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2d7619
movq %rax, 0x98(%rsp)
movl 0x38(%rbx), %eax
incl %eax
movl %eax, 0x2c(%rsp)
movl %eax, 0x38(%rbx)
movq %r14, %rbx
movl 0x6c(%rbp), %ecx
movq %r14, %rdi
movl $0x56, %esi
movl %r12d, %edx
movl %r15d, %r8d
callq 0x2b200c
movl %eax, %r14d
movq (%rbx), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2d9155
movl $0xfffffff7, %esi       # imm = 0xFFFFFFF7
movq 0x98(%rsp), %rdx
callq 0x29991d
jmp 0x2d9179
movq 0x88(%rbx), %rax
movslq 0x90(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movb $-0x9, -0x17(%rax,%rcx,8)
movq 0x98(%rsp), %rdx
movq %rdx, -0x8(%rax,%rcx,8)
leal 0x2(%r14), %edx
addl $0x4, %r14d
movq %rbx, %rdi
movl $0x10, %esi
movl %r14d, %ecx
movl %edx, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl $0xc, %esi
movl 0x2c(%rsp), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl %eax, %r14d
movl 0x6c(%rbp), %ecx
decl %r15d
movq %rbx, %rdi
movl $0x4d, %esi
movl %r12d, %edx
movl %r15d, %r8d
callq 0x2b200c
movl %r14d, 0x98(%rsp)
movq %rbx, %rdi
movl $0x78, %esi
movl 0x4c(%rsp), %r14d
movl %r14d, %edx
movl 0x30(%rsp), %r15d
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl $0x79, %esi
movl %r14d, %edx
movl 0x20(%rsp), %ecx
movl %r15d, %r8d
callq 0x2b200c
movl 0x80(%rbp), %edx
movq %rbx, %rdi
movl $0x34, %esi
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x2b200c
movl %eax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2c5ddf
movq %rbp, 0x20(%rsp)
testq %rbp, %rbp
je 0x2d9332
movq %rax, %r14
xorl %r13d, %r13d
leaq 0x1057bf(%rip), %r12    # 0x3dea05
movq 0x20(%rsp), %rbp
movq 0x50(%rbp), %r15
movl 0x5c(%rbp), %ecx
movq %r14, %rdi
movl $0x48, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2b200c
movq 0x70(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x0, %ecx
testq %rax, %rax
je 0x2d9278
movl (%rax), %ecx
cmpl %ecx, %r13d
movl $0x0, %edx
cmovgl %r13d, %edx
testq %rax, %rax
je 0x2d9296
cmpl %ecx, %r13d
movl %edx, %r13d
jg 0x2d9299
movl (%rax), %r13d
jmp 0x2d9299
movl %edx, %r13d
movq 0x20(%rsp), %rax
cmpl $0x0, 0x84(%rax)
jne 0x2d9325
movq 0x38(%r15), %rax
leaq 0x105749(%rip), %rcx    # 0x3de9fb
cmpq %rcx, %rax
setne %cl
cmpq %r12, %rax
setne %al
testb %al, %cl
jne 0x2d92ee
movl 0x68(%rbp), %ecx
movq %r14, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x68(%rbp), %ecx
incl %ecx
movq %r14, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2b200c
testb $0x10, 0x5(%r15)
je 0x2d9325
movl 0x64(%rbp), %edx
testl %edx, %edx
je 0x2d9325
movq %r14, %rdi
movl $0x8a, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x68(%rbp), %ecx
incl %ecx
movq %r14, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2b200c
movq 0x40(%rbp), %rbp
testq %rbp, %rbp
jne 0x2d924b
movq 0x10(%rsp), %r14
movl 0x38(%r14), %eax
leal 0x1(%rax), %ecx
addl %eax, %r13d
movl %r13d, 0x38(%r14)
movl %ecx, 0x70(%rsp)
movl 0xc(%rsp), %r12d
testl %r12d, %r12d
movq 0x20(%rsp), %r13
je 0x2d937f
movq 0x28(%r13), %rsi
movq %r14, %rdi
movl %r12d, %edx
callq 0x2c5f97
xorl %eax, %eax
cmpb $0x59, 0x20(%r13)
sete %al
leal (%rax,%rax,2), %edx
movq %r14, %rdi
movl %r12d, %esi
callq 0x2e7661
movl 0x8(%rsp), %r14d
testl %r14d, %r14d
movl 0x48(%rsp), %ebp
je 0x2d93c0
movq 0x30(%r13), %rsi
movq %rbx, %r15
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %edx
callq 0x2c5f97
xorl %eax, %eax
cmpb $0x59, 0x20(%r13)
sete %al
leal 0x1(%rax,%rax,2), %edx
movq %rbx, %rdi
movq %r15, %rbx
movl %r14d, %esi
callq 0x2e7661
cmpb $0x59, 0x20(%r13)
je 0x2d94a5
testl %r12d, %r12d
je 0x2d94a5
movb 0x21(%r13), %al
cmpb 0x22(%r13), %al
jne 0x2d94a5
xorl %ecx, %ecx
cmpb $0x56, %al
sete %cl
leal 0x37(,%rcx,2), %esi
movq %rbx, %rdi
movl %r12d, %edx
xorl %ecx, %ecx
movl %r14d, %r8d
callq 0x2b200c
movl %eax, 0xa0(%rsp)
leaq 0x50(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2e780e
movq %rbx, %rdi
movl $0x25, %esi
movq 0x38(%rsp), %r14
movl %r14d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %r15, %rdi
callq 0x2e79e9
movq %rbx, %rdi
movl $0x8a, %esi
movl %r14d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d947c
leaq 0x1f0a0e(%rip), %rcx    # 0x4c9e88
jmp 0x2d949d
leal -0x1(%rax), %ecx
movl 0xa0(%rsp), %edx
testl %edx, %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rbx), %rcx
movl %eax, 0x8(%rcx)
movl 0x8(%rsp), %r14d
cmpb $0x56, 0x21(%r13)
jne 0x2d94ce
testl %r14d, %r14d
je 0x2d94ce
cmpb $0x59, 0x20(%r13)
je 0x2d94ce
movq %rbx, %rdi
movl $0x6a, %esi
movl %r12d, %edx
movl %r14d, %ecx
movl %r12d, %r8d
callq 0x2b200c
cmpb $0x5a, 0x21(%r13)
movq 0xa8(%rsp), %r15
je 0x2d94f9
movq %rbx, %rdi
movl $0x25, %esi
movl 0xa4(%rsp), %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl $0x25, %esi
movq 0x38(%rsp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl $0x25, %esi
movl 0x34(%rsp), %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2b200c
cmpl $0x0, 0x1c(%rsp)
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2d95ba
movl (%r15), %r8d
decl %r8d
movq %rbx, %rdi
movl $0x4d, %esi
movl 0x44(%rsp), %edx
movl %ebp, %r12d
movl 0x1c(%rsp), %ebp
movl %ebp, %ecx
callq 0x2b200c
movl 0x7c(%rsp), %ecx
movl (%r15), %r8d
decl %r8d
movq %rbx, %rdi
movl $0x4d, %esi
movl %ebp, %edx
callq 0x2b200c
movl 0x84(%rsp), %ecx
movl (%r15), %r8d
decl %r8d
movq %rbx, %rdi
movl $0x4d, %esi
movl %ebp, %edx
callq 0x2b200c
movl 0x8c(%rsp), %ecx
movl (%r15), %r8d
decl %r8d
movq %rbx, %rdi
movl $0x4d, %esi
movl %ebp, %edx
movl %r12d, %ebp
movl 0xc(%rsp), %r12d
callq 0x2b200c
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d95e6
leaq 0x1f08a4(%rip), %rdx    # 0x4c9e88
jmp 0x2d9604
leal -0x1(%rax), %ecx
movl 0x30(%rsp), %edx
testl %edx, %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rdx
shlq $0x3, %rdx
addq 0x88(%rbx), %rdx
movl 0x1c(%rsp), %ecx
movl %eax, 0x8(%rdx)
testl %ecx, %ecx
je 0x2d9623
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movl 0x44(%rsp), %edx
movl %ebp, %r8d
callq 0x2e81cf
movb 0x21(%r13), %al
cmpb $0x56, %al
jne 0x2d96cd
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
cmpb $0x5a, 0x22(%r13)
je 0x2d9880
cmpb $0x59, 0x20(%r13)
jne 0x2d97a7
movq 0x10(%rsp), %rax
movl 0x44(%rax), %r14d
decl %r14d
movl %r14d, 0x44(%rax)
movl 0x90(%rbx), %r12d
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movl $0x39, %esi
movq 0x38(%rsp), %rdx
movl 0x8(%rsp), %ecx
movl 0x34(%rsp), %r8d
movl %r14d, %r9d
callq 0x2e86f2
movq %r15, %rdi
movl $0x2, %esi
movl 0xc(%rsp), %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
movl 0xc(%rsp), %r12d
jmp 0x2d986d
cmpb $0x58, 0x22(%r13)
jne 0x2d9732
cmpb $0x58, %al
jne 0x2d97ba
movq 0x20(%rsp), %rax
movb 0x20(%rax), %bpl
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x2e82ab
cmpb $0x59, %bpl
movl 0x48(%rsp), %ebp
movq 0x20(%rsp), %r13
jne 0x2d97ce
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x2, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
jmp 0x2d97ef
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
cmpb $0x5a, 0x22(%r13)
je 0x2d9880
cmpb $0x59, 0x20(%r13)
jne 0x2d97fb
movl 0x90(%rbx), %eax
movl %eax, 0x1c(%rsp)
movl 0x8(%rsp), %r15d
testl %r15d, %r15d
je 0x2d982a
movq 0x10(%rsp), %rax
movl 0x44(%rax), %r14d
decl %r14d
movl %r14d, 0x44(%rax)
leaq 0x50(%rsp), %rdi
movl $0x39, %esi
movq 0x38(%rsp), %rdx
movl %r15d, %ecx
movl 0x34(%rsp), %r8d
movl %r14d, %r9d
callq 0x2e86f2
jmp 0x2d982d
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
movl 0x8(%rsp), %edx
jmp 0x2d97dd
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x2e82ab
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq %r14, %rdi
movl $0x2, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2e82ab
jmp 0x2d9880
movl 0x8(%rsp), %r15d
testl %r15d, %r15d
je 0x2d9cd1
movq %rbx, %rdi
movl $0x30, %esi
movl %r15d, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2b200c
movl %eax, 0x10(%rsp)
jmp 0x2d9cd9
xorl %r14d, %r14d
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq %r12, %rdi
movl $0x2, %esi
movl 0xc(%rsp), %r12d
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2e82ab
testl %r15d, %r15d
je 0x2d9880
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl 0x1c(%rsp), %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2c91a7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2c91a7
movq 0xb0(%rsp), %rdi
callq 0x2daa07
cmpq $0x0, 0x10(%r13)
je 0x2d98cf
movq %rbx, %rdi
movl $0x45, %esi
xorl %edx, %edx
movl 0x2c(%rsp), %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl %eax, %r14d
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d98d4
leaq 0x1f05bb(%rip), %rcx    # 0x4c9e88
jmp 0x2d98f5
xorl %r14d, %r14d
jmp 0x2d98f8
leal -0x1(%rax), %ecx
movl 0x98(%rsp), %edx
testl %edx, %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rbx), %rcx
movl %eax, 0x8(%rcx)
movq %rbx, %rdi
movl $0x25, %esi
movl 0x4c(%rsp), %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl %eax, %r15d
movb 0x21(%r13), %bpl
cmpb $0x58, 0x22(%r13)
jne 0x2d9960
cmpb $0x58, %bpl
jne 0x2d99d2
movq 0x20(%rsp), %rax
movb 0x20(%rax), %bpl
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
movl 0x8(%rsp), %edx
xorl %ecx, %ecx
callq 0x2e82ab
cmpb $0x59, %bpl
jne 0x2d99e7
leaq 0x50(%rsp), %rdi
movl $0x2, %esi
movl %r12d, %edx
jmp 0x2d99e0
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
cmpb $0x56, %bpl
jne 0x2d9a04
movq 0x20(%rsp), %rbp
cmpb $0x59, 0x20(%rbp)
movl %r14d, 0x10(%rsp)
jne 0x2d9a75
movl 0x90(%rbx), %r12d
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x2, %esi
movl 0xc(%rsp), %edx
movl $0x1, %ecx
callq 0x2e82ab
movl %eax, %r13d
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2e82ab
movl %eax, %r14d
jmp 0x2d9b02
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
movl 0x8(%rsp), %edx
xorl %ecx, %ecx
callq 0x2e82ab
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq 0x20(%rsp), %rbp
jmp 0x2d9bd3
movl %r15d, 0x8(%rsp)
movl %r14d, %r15d
movl %r12d, %ebp
movl 0x90(%rbx), %r12d
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movl $0x1, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2e82ab
movl %eax, %r14d
movq %r13, %rdi
movl $0x2, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
movq 0x20(%rsp), %rbp
je 0x2d9aac
leaq 0x1f0415(%rip), %rcx    # 0x4c9e88
jmp 0x2d9ac8
cmpb $0x5a, 0x22(%rbp)
movl 0x90(%rbx), %r12d
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movl $0x1, %esi
jne 0x2d9ad8
movl 0xc(%rsp), %edx
movl $0x1, %ecx
callq 0x2e82ab
movl %eax, %r14d
movq %r13, %rdi
movl $0x2, %esi
xorl %edx, %edx
jmp 0x2d9af5
leal -0x1(%rax), %ecx
testl %r14d, %r14d
cmovnsl %r14d, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rbx), %rcx
movl %eax, 0x8(%rcx)
movl %r15d, %r14d
movl 0x8(%rsp), %r15d
jmp 0x2d9bd3
movl 0x8(%rsp), %edx
movl $0x1, %ecx
callq 0x2e82ab
movl %eax, %r14d
movq %r13, %rdi
movl $0x2, %esi
movl 0xc(%rsp), %edx
movl $0x1, %ecx
callq 0x2e82ab
movl %eax, %r13d
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x90(%rbx), %r12d
movq (%rbx), %rax
cmpb $0x0, 0x61(%rax)
je 0x2d9b30
leaq 0x1f035a(%rip), %rax    # 0x4c9e88
jmp 0x2d9b4d
leal -0x1(%r12), %eax
testl %r13d, %r13d
cmovnsl %r13d, %eax
cltq
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x88(%rbx), %rax
movl %r12d, 0x8(%rax)
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x2e82ab
movl %eax, %r13d
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d9b9d
movl %eax, 0x1f02fc(%rip)    # 0x4c9e90
leaq 0x1f02ed(%rip), %rcx    # 0x4c9e88
jmp 0x2d9bcb
leal -0x1(%rax), %ecx
testl %r14d, %r14d
cmovsl %ecx, %r14d
movq 0x88(%rbx), %rdx
movslq %r14d, %rsi
leaq (%rsi,%rsi,2), %rsi
testl %r13d, %r13d
cmovsl %ecx, %r13d
movl %eax, 0x8(%rdx,%rsi,8)
movslq %r13d, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,8), %rcx
movl 0x10(%rsp), %r14d
movl %eax, 0x8(%rcx)
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d9beb
leaq 0x1f029f(%rip), %rcx    # 0x4c9e88
jmp 0x2d9c07
leal -0x1(%rax), %ecx
testl %r15d, %r15d
cmovnsl %r15d, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rbx), %rcx
movl %eax, 0x8(%rcx)
movl 0x80(%rsp), %edx
movq %rbx, %rdi
movl $0x8a, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
cmpq $0x0, 0x10(%rbp)
je 0x2d9c79
movl 0x84(%rbp), %ecx
testl %ecx, %ecx
je 0x2d9c61
movq %rbx, %rdi
movl $0x45, %esi
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x88(%rbp), %ecx
movq %rbx, %rdi
movl $0x45, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2b200c
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d9c8b
leaq 0x1f0211(%rip), %rcx    # 0x4c9e88
jmp 0x2d9ca7
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal -0x1(%rax), %ecx
testl %r14d, %r14d
cmovnsl %r14d, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rbx), %rcx
movl %eax, 0x4(%rcx)
movq %rbx, %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 0x2b200c
movl $0x0, 0x10(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2e82ab
movq %r14, %rdi
movl $0x2, %esi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x2e82ab
testl %r15d, %r15d
je 0x2d9880
movl 0x90(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x2d9d22
leaq 0x1f0168(%rip), %rcx    # 0x4c9e88
jmp 0x2d9d40
leal -0x1(%rax), %ecx
movl 0x10(%rsp), %edx
testl %edx, %edx
cmovnsl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rbx), %rcx
movl %eax, 0x8(%rcx)
jmp 0x2d9880