// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4299d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x48(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movswl 0x46(%rax), %eax
movl %eax, -0x44(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x68(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x70(%rbp)
movl $0x0, -0xb8(%rbp)
movl $0x0, -0xbc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42d540
movl %eax, -0xb4(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x94(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x28(%rbp), %rax
movl 0x58(%rax), %eax
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
incl %eax
movl %eax, -0x3c(%rbp)
movl -0x80(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x88(%rbp)
movl -0x80(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
movl %eax, -0x11c(%rbp)
subl $0x56, %eax
je 0x4427f5
jmp 0x4427e5
movl -0x11c(%rbp), %eax
subl $0x5a, %eax
je 0x442824
jmp 0x44287c
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
je 0x442822
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x457770
cmpl $0x0, %eax
je 0x442822
movl $0x1, -0x8c(%rbp)
jmp 0x442886
movq -0x28(%rbp), %rdi
callq 0x4577f0
cmpl $0x0, %eax
jne 0x44287a
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x58, %eax
jne 0x44286e
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
je 0x44286c
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x457770
cmpl $0x0, %eax
je 0x44286c
movl $0x3, -0x8c(%rbp)
jmp 0x442878
movl $0x1, -0x8c(%rbp)
jmp 0x44287a
jmp 0x442886
movl $0x2, -0x8c(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movl -0x44(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x38(%rcx)
movl %eax, -0x60(%rbp)
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x38(%rcx)
movl %eax, -0x64(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x58, %eax
je 0x4428da
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x56, %eax
jne 0x4428ed
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x38(%rcx)
movl %eax, -0xb8(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x58, %eax
je 0x442907
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x56, %eax
jne 0x44291a
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x38(%rcx)
movl %eax, -0xbc(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x4c, %eax
je 0x4429f5
cmpq $0x0, -0x30(%rbp)
je 0x442940
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x120(%rbp)
jmp 0x44294a
xorl %eax, %eax
movl %eax, -0x120(%rbp)
jmp 0x44294a
movl -0x120(%rbp), %eax
movl %eax, -0xc0(%rbp)
movl -0x5c(%rbp), %eax
movq -0x28(%rbp), %rcx
addl 0x78(%rcx), %eax
movl %eax, -0x68(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x44297e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
addl -0x68(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
movl -0xc0(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
movl -0xc0(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
movl -0xc0(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
movl -0xc0(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x442a2b
movq -0x38(%rbp), %rdi
movl -0x40(%rbp), %edx
movl -0x48(%rbp), %ecx
movl -0x5c(%rbp), %r8d
addl -0x48(%rbp), %r8d
movl $0x59, %esi
callq 0x410130
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x4429fc
movq -0x38(%rbp), %rdi
movl -0x5c(%rbp), %edx
movl -0x44(%rbp), %ecx
movl -0x60(%rbp), %r8d
movl $0x5b, %esi
callq 0x410130
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x442b4d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xd4(%rbp)
movl -0x5c(%rbp), %eax
movq -0x28(%rbp), %rcx
addl 0x78(%rcx), %eax
movl %eax, -0xd8(%rbp)
movq -0x8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x440f30
movq %rax, -0xe0(%rbp)
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x38(%rcx)
movl %eax, -0x70(%rbp)
movq -0x38(%rbp), %rdi
movl -0xd8(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x6c(%rax), %ecx
movl -0xd4(%rbp), %r8d
movl $0x56, %esi
callq 0x410130
movl %eax, -0xc4(%rbp)
movq -0x38(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movl $0xfffffff7, %edx       # imm = 0xFFFFFFF7
callq 0x42a320
movq -0x38(%rbp), %rdi
movl -0xc4(%rbp), %edx
addl $0x2, %edx
movl -0xc4(%rbp), %ecx
addl $0x4, %ecx
movl -0xc4(%rbp), %r8d
addl $0x2, %r8d
movl $0x10, %esi
callq 0x410130
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %edx
movl $0xc, %esi
callq 0x42ba70
movl %eax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movl -0xd8(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x6c(%rax), %ecx
movl -0xd4(%rbp), %r8d
subl $0x1, %r8d
movl $0x4d, %esi
callq 0x410130
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %edx
movl -0x64(%rbp), %ecx
movl $0x78, %esi
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %edx
movl -0x60(%rbp), %ecx
movl -0x64(%rbp), %r8d
movl $0x79, %esi
callq 0x410130
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x80(%rax), %edx
movl -0x64(%rbp), %r8d
movl $0x34, %esi
xorl %ecx, %ecx
callq 0x410130
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4578a0
movl %eax, -0x90(%rbp)
cmpl $0x0, -0xb8(%rbp)
je 0x442bf4
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
movl -0xb8(%rbp), %edx
callq 0x429d30
movq -0x8(%rbp), %rdi
movl -0xb8(%rbp), %esi
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %ecx
xorl %edx, %edx
movl $0x3, %eax
cmpl $0x59, %ecx
cmovel %eax, %edx
addl $0x0, %edx
callq 0x457a20
cmpl $0x0, -0xbc(%rbp)
je 0x442c3b
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rsi
movl -0xbc(%rbp), %edx
callq 0x429d30
movq -0x8(%rbp), %rdi
movl -0xbc(%rbp), %esi
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %ecx
xorl %edx, %edx
movl $0x3, %eax
cmpl $0x59, %ecx
cmovel %eax, %edx
addl $0x1, %edx
callq 0x457a20
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
je 0x442d19
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x22(%rcx), %ecx
cmpl %ecx, %eax
jne 0x442d19
cmpl $0x0, -0xb8(%rbp)
je 0x442d19
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %edx
movl $0x37, %eax
movl $0x39, %ecx
cmpl $0x56, %edx
cmovel %ecx, %eax
movl %eax, -0xe4(%rbp)
movq -0x38(%rbp), %rdi
movl -0xe4(%rbp), %esi
movl -0xb8(%rbp), %edx
movl -0xbc(%rbp), %r8d
xorl %ecx, %ecx
callq 0x410130
movl %eax, -0xe8(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
callq 0x457ba0
movq -0x38(%rbp), %rdi
movl -0x80(%rbp), %edx
movl $0x25, %esi
movl $0x1, %ecx
callq 0x410100
leaq -0xb0(%rbp), %rdi
callq 0x457d60
movq -0x38(%rbp), %rdi
movl -0x80(%rbp), %edx
movl $0x8a, %esi
callq 0x42ba70
movq -0x38(%rbp), %rdi
movl -0xb4(%rbp), %ecx
movl $0xb, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0xe8(%rbp), %esi
callq 0x429a70
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x56, %eax
jne 0x442d5d
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
je 0x442d5d
cmpl $0x0, -0xbc(%rbp)
je 0x442d5d
movq -0x38(%rbp), %rdi
movl -0xb8(%rbp), %edx
movl -0xbc(%rbp), %ecx
movl -0xb8(%rbp), %r8d
movl $0x6a, %esi
callq 0x410130
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x5a, %eax
je 0x442d83
movq -0x38(%rbp), %rdi
movl -0x88(%rbp), %edx
movl $0x25, %esi
movl $0x1, %ecx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0x80(%rbp), %edx
movl $0x25, %esi
movl $0x1, %ecx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0x78(%rbp), %edx
movl $0x25, %esi
movl $0x1, %ecx
callq 0x410100
cmpl $0x0, -0x6c(%rbp)
je 0x442e3f
cmpq $0x0, -0x30(%rbp)
je 0x442e3f
movq -0x38(%rbp), %rdi
movl -0x68(%rbp), %edx
movl -0x6c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl (%rax), %r8d
subl $0x1, %r8d
movl $0x4d, %esi
callq 0x410130
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0x84(%rbp), %ecx
movq -0x30(%rbp), %rax
movl (%rax), %r8d
subl $0x1, %r8d
movl $0x4d, %esi
callq 0x410130
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0x7c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl (%rax), %r8d
subl $0x1, %r8d
movl $0x4d, %esi
callq 0x410130
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0x74(%rbp), %ecx
movq -0x30(%rbp), %rax
movl (%rax), %r8d
subl $0x1, %r8d
movl $0x4d, %esi
callq 0x410130
movq -0x38(%rbp), %rdi
movl -0xb4(%rbp), %ecx
movl $0xb, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x429a70
cmpl $0x0, -0x6c(%rbp)
je 0x442e81
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x68(%rbp), %edx
movl -0x6c(%rbp), %ecx
movl -0xb4(%rbp), %r8d
callq 0x458110
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x56, %eax
jne 0x442f9a
leaq -0xb0(%rbp), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x5a, %eax
je 0x442f95
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
jne 0x442f61
movq -0x8(%rbp), %rdi
callq 0x42d540
movl %eax, -0xec(%rbp)
movq -0x38(%rbp), %rdi
callq 0x430ae0
movl %eax, -0xf0(%rbp)
movl -0x80(%rbp), %edx
movl -0xbc(%rbp), %ecx
movl -0x78(%rbp), %r8d
movl -0xec(%rbp), %r9d
leaq -0xb0(%rbp), %rdi
movl $0x39, %esi
callq 0x4586d0
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
movq -0x38(%rbp), %rdi
movl -0xf0(%rbp), %ecx
movl $0xb, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0xec(%rbp), %esi
callq 0x42dc90
jmp 0x442f93
movl -0xbc(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x458210
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
jmp 0x442f95
jmp 0x4431ca
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x58, %eax
jne 0x44305c
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %ecx
xorl %eax, %eax
cmpl $0x58, %ecx
movb %al, -0x121(%rbp)
jne 0x442fd4
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
sete %al
movb %al, -0x121(%rbp)
movb -0x121(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xf4(%rbp)
movl -0xbc(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
callq 0x458210
cmpl $0x0, -0xf4(%rbp)
je 0x443020
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
cmpl $0x0, -0xf4(%rbp)
jne 0x443057
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
jmp 0x4431c8
movl $0x0, -0xf8(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x5a, %eax
je 0x4431c6
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
jne 0x443151
movl $0x0, -0xfc(%rbp)
movq -0x38(%rbp), %rdi
callq 0x430ae0
movl %eax, -0xf8(%rbp)
cmpl $0x0, -0xbc(%rbp)
je 0x4430f3
movq -0x8(%rbp), %rdi
callq 0x42d540
movl %eax, -0xfc(%rbp)
movl -0x80(%rbp), %edx
movl -0xbc(%rbp), %ecx
movl -0x78(%rbp), %r8d
movl -0xfc(%rbp), %r9d
leaq -0xb0(%rbp), %rdi
movl $0x39, %esi
callq 0x4586d0
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
cmpl $0x0, -0xbc(%rbp)
je 0x44314f
movq -0x38(%rbp), %rdi
movl -0xf8(%rbp), %ecx
movl $0xb, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0xfc(%rbp), %esi
callq 0x42dc90
jmp 0x4431c4
cmpl $0x0, -0xbc(%rbp)
je 0x44317c
movq -0x38(%rbp), %rdi
movl -0xbc(%rbp), %edx
movl $0x30, %esi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x410130
movl %eax, -0xf8(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
cmpl $0x0, -0xbc(%rbp)
je 0x4431c2
movq -0x38(%rbp), %rdi
movl -0xf8(%rbp), %esi
callq 0x429a70
jmp 0x4431c4
jmp 0x4431c6
jmp 0x4431c8
jmp 0x4431ca
movq -0x38(%rbp), %rdi
movl -0xb4(%rbp), %esi
callq 0x42dc90
movq -0x18(%rbp), %rdi
callq 0x444120
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x44320f
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %ecx
movl $0x45, %esi
xorl %edx, %edx
callq 0x410100
movl %eax, -0x54(%rbp)
movq -0x38(%rbp), %rdi
movl -0x50(%rbp), %esi
callq 0x429a70
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %edx
movl $0x25, %esi
callq 0x42ba70
movl %eax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x58, %eax
jne 0x4432c3
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %ecx
xorl %eax, %eax
cmpl $0x58, %ecx
movb %al, -0x122(%rbp)
jne 0x44325d
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
sete %al
movb %al, -0x122(%rbp)
movb -0x122(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x100(%rbp)
movl -0xbc(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
callq 0x458210
cmpl $0x0, -0x100(%rbp)
je 0x4432a9
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
jmp 0x4434f8
movq -0x28(%rbp), %rax
movzbl 0x21(%rax), %eax
cmpl $0x56, %eax
jne 0x443479
leaq -0xb0(%rbp), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
movq -0x28(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x59, %eax
jne 0x443347
movq -0x38(%rbp), %rdi
callq 0x430ae0
movl %eax, -0x104(%rbp)
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %ecx
callq 0x458210
movl %eax, -0x10c(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
movl %ecx, %esi
callq 0x458210
movl %eax, -0x108(%rbp)
jmp 0x4433f4
movq -0x28(%rbp), %rax
movzbl 0x22(%rax), %eax
cmpl $0x5a, %eax
jne 0x4433a2
movq -0x38(%rbp), %rdi
callq 0x430ae0
movl %eax, -0x104(%rbp)
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x1, %ecx
movl %ecx, %esi
callq 0x458210
movl %eax, -0x108(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x458210
movl %eax, -0x10c(%rbp)
jmp 0x4433f2
movq -0x38(%rbp), %rdi
callq 0x430ae0
movl %eax, -0x104(%rbp)
movl -0xbc(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x1, %ecx
movl %ecx, %esi
callq 0x458210
movl %eax, -0x108(%rbp)
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %ecx
callq 0x458210
movl %eax, -0x10c(%rbp)
jmp 0x4433f4
movq -0x38(%rbp), %rdi
movl -0x104(%rbp), %ecx
movl $0xb, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0x10c(%rbp), %esi
callq 0x429a70
movq -0x38(%rbp), %rdi
callq 0x430ae0
movl %eax, -0x104(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
movl %ecx, %esi
callq 0x458210
movl %eax, -0x110(%rbp)
movq -0x38(%rbp), %rdi
movl -0x104(%rbp), %ecx
movl $0xb, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0x108(%rbp), %esi
callq 0x429a70
movq -0x38(%rbp), %rdi
movl -0x110(%rbp), %esi
callq 0x429a70
jmp 0x4434f6
leaq -0xb0(%rbp), %rdi
movl $0x3, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x458210
movq -0x38(%rbp), %rdi
callq 0x430ae0
movl %eax, -0x118(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
movl %ecx, %esi
callq 0x458210
movl %eax, -0x114(%rbp)
movl -0xb8(%rbp), %edx
leaq -0xb0(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x458210
movq -0x38(%rbp), %rdi
movl -0x118(%rbp), %ecx
movl $0xb, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movl -0x114(%rbp), %esi
callq 0x429a70
jmp 0x4434f8
movq -0x38(%rbp), %rdi
movl -0x58(%rbp), %esi
callq 0x429a70
movq -0x38(%rbp), %rdi
movl -0x80(%rbp), %edx
movl $0x8a, %esi
callq 0x42ba70
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4435aa
movq -0x28(%rbp), %rax
cmpl $0x0, 0x84(%rax)
je 0x443568
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x84(%rax), %ecx
movl $0x45, %esi
movl $0x1, %edx
callq 0x410100
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x88(%rax), %ecx
movl $0x45, %esi
xorl %edx, %edx
callq 0x410100
movq -0x38(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x128(%rbp)
movq -0x38(%rbp), %rdi
callq 0x430ae0
movq -0x130(%rbp), %rdi
movl -0x128(%rbp), %esi
movl %eax, %edx
callq 0x430c80
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %edx
movl $0x41, %esi
callq 0x42ba70
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)