// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: multiSelectOrderBy
static int multiSelectOrderBy(
  Parse *pParse,        /* Parsing context */
  Select *p,            /* The right-most of SELECTs to be coded */
  SelectDest *pDest     /* What to do with query results */
){
  int i, j;             /* Loop counters */
  Select *pPrior;       /* Another SELECT immediately to our left */
  Vdbe *v;              /* Generate code to this VDBE */
  SelectDest destA;     /* Destination for coroutine A */
  SelectDest destB;     /* Destination for coroutine B */
  int regAddrA;         /* Address register for select-A coroutine */
  int regAddrB;         /* Address register for select-B coroutine */
  int addrSelectA;      /* Address of the select-A coroutine */
  int addrSelectB;      /* Address of the select-B coroutine */
  int regOutA;          /* Address register for the output-A subroutine */
  int regOutB;          /* Address register for the output-B subroutine */
  int addrOutA;         /* Address of the output-A subroutine */
  int addrOutB = 0;     /* Address of the output-B subroutine */
  int addrEofA;         /* Address of the select-A-exhausted subroutine */
  int addrEofA_noB;     /* Alternate addrEofA if B is uninitialized */
  int addrEofB;         /* Address of the select-B-exhausted subroutine */
  int addrAltB;         /* Address of the A<B subroutine */
  int addrAeqB;         /* Address of the A==B subroutine */
  int addrAgtB;         /* Address of the A>B subroutine */
  int regLimitA;        /* Limit register for select-A */
  int regLimitB;        /* Limit register for select-A */
  int regPrev;          /* A range of registers to hold previous output */
  int savedLimit;       /* Saved value of p->iLimit */
  int savedOffset;      /* Saved value of p->iOffset */
  int labelCmpr;        /* Label for the start of the merge algorithm */
  int labelEnd;         /* Label for the end of the overall SELECT stmt */
  int addr1;            /* Jump instructions that get retargetted */
  int op;               /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
  KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
  KeyInfo *pKeyMerge;   /* Comparison information for merging rows */
  sqlite3 *db;          /* Database connection */
  ExprList *pOrderBy;   /* The ORDER BY clause */
  int nOrderBy;         /* Number of terms in the ORDER BY clause */
  int *aPermute;        /* Mapping from ORDER BY terms to result set columns */
#ifndef SQLITE_OMIT_EXPLAIN
  int iSub1;            /* EQP id of left-hand query */
  int iSub2;            /* EQP id of right-hand query */
#endif

  assert( p->pOrderBy!=0 );
  assert( pKeyDup==0 ); /* "Managed" code needs this.  Ticket #3382. */
  db = pParse->db;
  v = pParse->pVdbe;
  assert( v!=0 );       /* Already thrown the error if VDBE alloc failed */
  labelEnd = sqlite3VdbeMakeLabel(v);
  labelCmpr = sqlite3VdbeMakeLabel(v);


  /* Patch up the ORDER BY clause
  */
  op = p->op;  
  pPrior = p->pPrior;
  assert( pPrior->pOrderBy==0 );
  pOrderBy = p->pOrderBy;
  assert( pOrderBy );
  nOrderBy = pOrderBy->nExpr;

  /* For operators other than UNION ALL we have to make sure that
  ** the ORDER BY clause covers every term of the result set.  Add
  ** terms to the ORDER BY clause as necessary.
  */
  if( op!=TK_ALL ){
    for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
      struct ExprList_item *pItem;
      for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
        assert( pItem->u.x.iOrderByCol>0 );
        if( pItem->u.x.iOrderByCol==i ) break;
      }
      if( j==nOrderBy ){
        Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
        if( pNew==0 ) return SQLITE_NOMEM;
        pNew->flags |= EP_IntValue;
        pNew->u.iValue = i;
        pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
        if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
      }
    }
  }

  /* Compute the comparison permutation and keyinfo that is used with
  ** the permutation used to determine if the next
  ** row of results comes from selectA or selectB.  Also add explicit
  ** collations to the ORDER BY clause terms so that when the subqueries
  ** to the right and the left are evaluated, they use the correct
  ** collation.
  */
  aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy);
  if( aPermute ){
    struct ExprList_item *pItem;
    for(i=0, pItem=pOrderBy->a; i<nOrderBy; i++, pItem++){
      assert( pItem->u.x.iOrderByCol>0 );
      assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
      aPermute[i] = pItem->u.x.iOrderByCol - 1;
    }
    pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
  }else{
    pKeyMerge = 0;
  }

  /* Reattach the ORDER BY clause to the query.
  */
  p->pOrderBy = pOrderBy;
  pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);

  /* Allocate a range of temporary registers and the KeyInfo needed
  ** for the logic that removes duplicate result rows when the
  ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
  */
  if( op==TK_ALL ){
    regPrev = 0;
  }else{
    int nExpr = p->pEList->nExpr;
    assert( nOrderBy>=nExpr || db->mallocFailed );
    regPrev = pParse->nMem+1;
    pParse->nMem += nExpr+1;
    sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
    pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
    if( pKeyDup ){
      assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
      for(i=0; i<nExpr; i++){
        pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
        pKeyDup->aSortOrder[i] = 0;
      }
    }
  }
 
  /* Separate the left and the right query from one another
  */
  p->pPrior = 0;
  pPrior->pNext = 0;
  sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
  if( pPrior->pPrior==0 ){
    sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
  }

  /* Compute the limit registers */
  computeLimitRegisters(pParse, p, labelEnd);
  if( p->iLimit && op==TK_ALL ){
    regLimitA = ++pParse->nMem;
    regLimitB = ++pParse->nMem;
    sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
                                  regLimitA);
    sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
  }else{
    regLimitA = regLimitB = 0;
  }
  sqlite3ExprDelete(db, p->pLimit);
  p->pLimit = 0;
  sqlite3ExprDelete(db, p->pOffset);
  p->pOffset = 0;

  regAddrA = ++pParse->nMem;
  regAddrB = ++pParse->nMem;
  regOutA = ++pParse->nMem;
  regOutB = ++pParse->nMem;
  sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
  sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);

  /* Generate a coroutine to evaluate the SELECT statement to the
  ** left of the compound operator - the "A" select.
  */
  addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
  addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
  VdbeComment((v, "left SELECT"));
  pPrior->iLimit = regLimitA;
  explainSetInteger(iSub1, pParse->iNextSelectId);
  sqlite3Select(pParse, pPrior, &destA);
  sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrA);
  sqlite3VdbeJumpHere(v, addr1);

  /* Generate a coroutine to evaluate the SELECT statement on 
  ** the right - the "B" select
  */
  addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
  addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
  VdbeComment((v, "right SELECT"));
  savedLimit = p->iLimit;
  savedOffset = p->iOffset;
  p->iLimit = regLimitB;
  p->iOffset = 0;  
  explainSetInteger(iSub2, pParse->iNextSelectId);
  sqlite3Select(pParse, p, &destB);
  p->iLimit = savedLimit;
  p->iOffset = savedOffset;
  sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrB);

  /* Generate a subroutine that outputs the current row of the A
  ** select as the next output row of the compound select.
  */
  VdbeNoopComment((v, "Output routine for A"));
  addrOutA = generateOutputSubroutine(pParse,
                 p, &destA, pDest, regOutA,
                 regPrev, pKeyDup, labelEnd);
  
  /* Generate a subroutine that outputs the current row of the B
  ** select as the next output row of the compound select.
  */
  if( op==TK_ALL || op==TK_UNION ){
    VdbeNoopComment((v, "Output routine for B"));
    addrOutB = generateOutputSubroutine(pParse,
                 p, &destB, pDest, regOutB,
                 regPrev, pKeyDup, labelEnd);
  }
  sqlite3KeyInfoUnref(pKeyDup);

  /* Generate a subroutine to run when the results from select A
  ** are exhausted and only data in select B remains.
  */
  if( op==TK_EXCEPT || op==TK_INTERSECT ){
    addrEofA_noB = addrEofA = labelEnd;
  }else{  
    VdbeNoopComment((v, "eof-A subroutine"));
    addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
    addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
                                     VdbeCoverage(v);
    sqlite3VdbeGoto(v, addrEofA);
    p->nSelectRow += pPrior->nSelectRow;
  }

  /* Generate a subroutine to run when the results from select B
  ** are exhausted and only data in select A remains.
  */
  if( op==TK_INTERSECT ){
    addrEofB = addrEofA;
    if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
  }else{  
    VdbeNoopComment((v, "eof-B subroutine"));
    addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
    sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
    sqlite3VdbeGoto(v, addrEofB);
  }

  /* Generate code to handle the case of A<B
  */
  VdbeNoopComment((v, "A-lt-B subroutine"));
  addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
  sqlite3VdbeGoto(v, labelCmpr);

  /* Generate code to handle the case of A==B
  */
  if( op==TK_ALL ){
    addrAeqB = addrAltB;
  }else if( op==TK_INTERSECT ){
    addrAeqB = addrAltB;
    addrAltB++;
  }else{
    VdbeNoopComment((v, "A-eq-B subroutine"));
    addrAeqB =
    sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
    sqlite3VdbeGoto(v, labelCmpr);
  }

  /* Generate code to handle the case of A>B
  */
  VdbeNoopComment((v, "A-gt-B subroutine"));
  addrAgtB = sqlite3VdbeCurrentAddr(v);
  if( op==TK_ALL || op==TK_UNION ){
    sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
  }
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
  sqlite3VdbeGoto(v, labelCmpr);

  /* This code runs once to initialize everything.
  */
  sqlite3VdbeJumpHere(v, addr1);
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
  sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);

  /* Implement the main merge loop
  */
  sqlite3VdbeResolveLabel(v, labelCmpr);
  sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
  sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
                         (char*)pKeyMerge, P4_KEYINFO);
  sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
  sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);

  /* Jump to the this point in order to terminate the query.
  */
  sqlite3VdbeResolveLabel(v, labelEnd);

  /* Set the number of output columns
  */
  if( pDest->eDest==SRT_Output ){
    Select *pFirst = pPrior;
    while( pFirst->pPrior ) pFirst = pFirst->pPrior;
    generateColumnNames(pParse, pFirst->pSrc, pFirst->pEList);
  }

  /* Reassembly the compound query so that it will be freed correctly
  ** by the calling function */
  if( p->pPrior ){
    sqlite3SelectDelete(db, p->pPrior);
  }
  p->pPrior = pPrior;
  pPrior->pNext = p;

  /*** TBD:  Insert subroutine calls to close cursors on incomplete
  **** subqueries ****/
  explainComposite(pParse, p->op, iSub1, iSub2, 0);
  return pParse->nErr!=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x88(%rbp)
movq $0x0, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6e5a0
movl %eax, -0xbc(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6e5a0
movl %eax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0xc4(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xec(%rbp)
cmpl $0x74, -0xc4(%rbp)
je 0x81bfe
movl $0x1, -0x24(%rbp)
movq -0xe0(%rbp), %rax
movzbl 0x51(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x129(%rbp)
jne 0x81acd
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
setle %al
movb %al, -0x129(%rbp)
movb -0x129(%rbp), %al
testb $0x1, %al
jne 0x81adc
jmp 0x81bfc
movl $0x0, -0x28(%rbp)
movq -0xe8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x108(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xec(%rbp), %eax
jge 0x81b31
movq -0x108(%rbp), %rax
movzwl 0x1c(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x81b12
jmp 0x81b31
jmp 0x81b14
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x108(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x108(%rbp)
jmp 0x81af5
movl -0x28(%rbp), %eax
cmpl -0xec(%rbp), %eax
jne 0x81bec
movq -0xe0(%rbp), %rdi
movl $0x84, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x61600
movq %rax, -0x110(%rbp)
cmpq $0x0, -0x110(%rbp)
jne 0x81b72
movl $0x7, -0x4(%rbp)
jmp 0x824e5
movq -0x110(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %ecx
movq -0x110(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq -0x110(%rbp), %rdx
callq 0x613a0
movq %rax, -0xe8(%rbp)
cmpq $0x0, -0xe8(%rbp)
je 0x81bea
movl -0x24(%rbp), %eax
movw %ax, %cx
movq -0xe8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xec(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0xec(%rbp)
movslq %edx, %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movw %cx, 0x1c(%rax)
jmp 0x81bec
jmp 0x81bee
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x81aa0
jmp 0x81bfe
movq -0xe0(%rbp), %rdi
movslq -0xec(%rbp), %rsi
shlq $0x2, %rsi
callq 0x175d0
movq %rax, -0xf8(%rbp)
cmpq $0x0, -0xf8(%rbp)
je 0x81c9e
movl $0x0, -0x24(%rbp)
movq -0xe8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x118(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xec(%rbp), %eax
jge 0x81c83
movq -0x118(%rbp), %rax
movzwl 0x1c(%rax), %edx
subl $0x1, %edx
movq -0xf8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x118(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x118(%rbp)
jmp 0x81c3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x82660
movq %rax, -0xd8(%rbp)
jmp 0x81ca9
movq $0x0, -0xd8(%rbp)
movq -0xe8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0xe8(%rbp), %rsi
xorl %edx, %edx
callq 0x71a60
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
cmpl $0x74, -0xc4(%rbp)
jne 0x81cf0
movl $0x0, -0xac(%rbp)
jmp 0x81db7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x11c(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
movl -0x11c(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
addl 0x54(%rax), %ecx
movl %ecx, 0x54(%rax)
movq -0x38(%rbp), %rdi
movl -0xac(%rbp), %ecx
movl $0x17, %esi
xorl %edx, %edx
callq 0x6c310
movq -0xe0(%rbp), %rdi
movl -0x11c(%rbp), %esi
movl $0x1, %edx
callq 0x6c670
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0xd0(%rbp)
je 0x81db5
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x11c(%rbp), %eax
jge 0x81db3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x825d0
movq %rax, %rdx
movq -0xd0(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movq -0xd0(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x81d67
jmp 0x81db5
jmp 0x81db7
movq -0x18(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdx
leaq 0x25ad0(%rip), %rcx     # 0xa78b6
callq 0x7a5e0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x81e12
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdx
leaq 0x25aa9(%rip), %rcx     # 0xa78b6
callq 0x7a5e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xbc(%rbp), %edx
callq 0x7de00
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x81ed3
cmpl $0x74, -0xc4(%rbp)
jne 0x81ed3
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x54(%rcx)
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x54(%rcx)
movl %eax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x81e8d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0x13c(%rbp)
jmp 0x81e9a
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x13c(%rbp)
movq -0x138(%rbp), %rdi
movl -0x13c(%rbp), %edx
movl -0xa4(%rbp), %ecx
movl $0x1f, %esi
callq 0x6c310
movq -0x38(%rbp), %rdi
movl -0xa4(%rbp), %edx
movl -0xa8(%rbp), %ecx
movl $0x1f, %esi
callq 0x6c310
jmp 0x81ee7
movl $0x0, -0xa8(%rbp)
movl $0x0, -0xa4(%rbp)
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x536c0
movq -0x18(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x536c0
movq -0x18(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x54(%rcx)
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x54(%rcx)
movl %eax, -0x70(%rbp)
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x54(%rcx)
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x54(%rcx)
movl %eax, -0x80(%rbp)
movl -0x6c(%rbp), %edx
leaq -0x50(%rbp), %rdi
movl $0xd, %esi
callq 0x72520
movl -0x70(%rbp), %edx
leaq -0x68(%rbp), %rdi
movl $0xd, %esi
callq 0x72520
movq -0x38(%rbp), %rdi
callq 0x6c2b0
addl $0x1, %eax
movl %eax, -0x74(%rbp)
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0x74(%rbp), %r8d
movl $0x11, %esi
xorl %ecx, %ecx
callq 0x56c10
movl %eax, -0xc0(%rbp)
movl -0xa4(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x200(%rax), %eax
movl %eax, -0xfc(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x5f480
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl $0x12, %esi
callq 0x6e570
movq -0x38(%rbp), %rdi
movl -0xc0(%rbp), %esi
callq 0x6be30
movq -0x38(%rbp), %rdi
callq 0x6c2b0
addl $0x1, %eax
movl %eax, -0x78(%rbp)
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %edx
movl -0x78(%rbp), %r8d
movl $0x11, %esi
xorl %ecx, %ecx
callq 0x56c10
movl %eax, -0xc0(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xb4(%rbp)
movl -0xa8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x200(%rax), %eax
movl %eax, -0x100(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x5f480
movl -0xb0(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xb4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %edx
movl $0x12, %esi
callq 0x6e570
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl -0x7c(%rbp), %r8d
movl -0xac(%rbp), %r9d
movq -0xd0(%rbp), %r10
movl -0xbc(%rbp), %eax
leaq -0x50(%rbp), %rdx
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x82800
movl %eax, -0x84(%rbp)
cmpl $0x74, -0xc4(%rbp)
je 0x820fa
cmpl $0x73, -0xc4(%rbp)
jne 0x82135
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl -0x80(%rbp), %r8d
movl -0xac(%rbp), %r9d
movq -0xd0(%rbp), %r10
movl -0xbc(%rbp), %eax
leaq -0x68(%rbp), %rdx
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x82800
movl %eax, -0x88(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x355b0
cmpl $0x75, -0xc4(%rbp)
je 0x82153
cmpl $0x76, -0xc4(%rbp)
jne 0x82167
movl -0xbc(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl %eax, -0x90(%rbp)
jmp 0x821c4
movq -0x38(%rbp), %rdi
movl -0x80(%rbp), %edx
movl -0x88(%rbp), %ecx
movl $0xf, %esi
callq 0x6c310
movl %eax, -0x8c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %edx
movl -0xbc(%rbp), %ecx
movl $0x14, %esi
callq 0x6c310
movl %eax, -0x90(%rbp)
movq -0x38(%rbp), %rdi
movl -0x8c(%rbp), %esi
callq 0x6c1b0
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x76, -0xc4(%rbp)
jne 0x821fd
movl -0x8c(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0x821fb
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x82240
movq -0x38(%rbp), %rdi
movl -0x7c(%rbp), %edx
movl -0x84(%rbp), %ecx
movl $0xf, %esi
callq 0x6c310
movl %eax, -0x94(%rbp)
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0xbc(%rbp), %ecx
movl $0x14, %esi
callq 0x6c310
movq -0x38(%rbp), %rdi
movl -0x94(%rbp), %esi
callq 0x6c1b0
movq -0x38(%rbp), %rdi
movl -0x7c(%rbp), %edx
movl -0x84(%rbp), %ecx
movl $0xf, %esi
callq 0x6c310
movl %eax, -0x98(%rbp)
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0x8c(%rbp), %ecx
movl $0x14, %esi
callq 0x6c310
movq -0x38(%rbp), %rdi
movl -0xb8(%rbp), %esi
callq 0x6c1b0
cmpl $0x74, -0xc4(%rbp)
jne 0x8229a
movl -0x98(%rbp), %eax
movl %eax, -0x9c(%rbp)
jmp 0x822ee
cmpl $0x76, -0xc4(%rbp)
jne 0x822c0
movl -0x98(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
jmp 0x822ec
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0x8c(%rbp), %ecx
movl $0x14, %esi
callq 0x6c310
movl %eax, -0x9c(%rbp)
movq -0x38(%rbp), %rdi
movl -0xb8(%rbp), %esi
callq 0x6c1b0
jmp 0x822ee
movq -0x38(%rbp), %rdi
callq 0x6c2b0
movl %eax, -0xa0(%rbp)
cmpl $0x74, -0xc4(%rbp)
je 0x8230f
cmpl $0x73, -0xc4(%rbp)
jne 0x82326
movq -0x38(%rbp), %rdi
movl -0x80(%rbp), %edx
movl -0x88(%rbp), %ecx
movl $0xf, %esi
callq 0x6c310
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %edx
movl -0x94(%rbp), %ecx
movl $0x14, %esi
callq 0x6c310
movq -0x38(%rbp), %rdi
movl -0xb8(%rbp), %esi
callq 0x6c1b0
movq -0x38(%rbp), %rdi
movl -0xc0(%rbp), %esi
callq 0x6be30
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %edx
movl -0x90(%rbp), %ecx
movl $0x14, %esi
callq 0x6c310
movq -0x38(%rbp), %rdi
movl -0x70(%rbp), %edx
movl -0x94(%rbp), %ecx
movl $0x14, %esi
callq 0x6c310
movq -0x38(%rbp), %rdi
movl -0xb8(%rbp), %esi
callq 0x6e780
movq -0x38(%rbp), %rdi
movq -0xf8(%rbp), %r9
movl $0x2a, %esi
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
movl $0xfffffff1, (%rsp)     # imm = 0xFFFFFFF1
callq 0x6be70
movq -0x38(%rbp), %rdi
movl -0x48(%rbp), %edx
movl -0x60(%rbp), %ecx
movl -0xec(%rbp), %r8d
movq -0xd8(%rbp), %r9
movl $0x2b, %esi
movl $0xfffffffa, (%rsp)     # imm = 0xFFFFFFFA
callq 0x6be70
movq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x17b70
movq -0x38(%rbp), %rdi
movl -0x98(%rbp), %edx
movl -0x9c(%rbp), %ecx
movl -0xa0(%rbp), %r8d
movl $0x2c, %esi
callq 0x56c10
movq -0x38(%rbp), %rdi
movl -0xbc(%rbp), %esi
callq 0x6e780
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x8247b
movq -0x30(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x8245d
movq -0x128(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x128(%rbp)
jmp 0x8243b
movq -0x10(%rbp), %rdi
movq -0x128(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x128(%rbp), %rax
movq (%rax), %rdx
callq 0x80c70
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x8249a
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x53840
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %esi
movl -0xfc(%rbp), %edx
movl -0x100(%rbp), %ecx
xorl %r8d, %r8d
callq 0x82500
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)