// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resolveSelectStep
static int resolveSelectStep(Walker *pWalker, Select *p){
  NameContext *pOuterNC;  /* Context that contains this SELECT */
  NameContext sNC;        /* Name context of this SELECT */
  int isCompound;         /* True if p is a compound select */
  int nCompound;          /* Number of compound terms processed so far */
  Parse *pParse;          /* Parsing context */
  int i;                  /* Loop counter */
  ExprList *pGroupBy;     /* The GROUP BY clause */
  Select *pLeftmost;      /* Left-most of SELECT of a compound */
  sqlite3 *db;            /* Database connection */


  assert( p!=0 );
  if( p->selFlags & SF_Resolved ){
    return WRC_Prune;
  }
  pOuterNC = pWalker->u.pNC;
  pParse = pWalker->pParse;
  db = pParse->db;

  /* Normally sqlite3SelectExpand() will be called first and will have
  ** already expanded this SELECT.  However, if this is a subquery within
  ** an expression, sqlite3ResolveExprNames() will be called without a
  ** prior call to sqlite3SelectExpand().  When that happens, let
  ** sqlite3SelectPrep() do all of the processing for this SELECT.
  ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
  ** this routine in the correct order.
  */
  if( (p->selFlags & SF_Expanded)==0 ){
    sqlite3SelectPrep(pParse, p, pOuterNC);
    return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
  }

  isCompound = p->pPrior!=0;
  nCompound = 0;
  pLeftmost = p;
  while( p ){
    assert( (p->selFlags & SF_Expanded)!=0 );
    assert( (p->selFlags & SF_Resolved)==0 );
    p->selFlags |= SF_Resolved;

    /* Resolve the expressions in the LIMIT and OFFSET clauses. These
    ** are not allowed to refer to any names, so pass an empty NameContext.
    */
    memset(&sNC, 0, sizeof(sNC));
    sNC.pParse = pParse;
    sNC.pWinSelect = p;
    if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
      return WRC_Abort;
    }

    /* If the SF_Converted flags is set, then this Select object was
    ** was created by the convertCompoundSelectToSubquery() function.
    ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
    ** as if it were part of the sub-query, not the parent. This block
    ** moves the pOrderBy down to the sub-query. It will be moved back
    ** after the names have been resolved.  */
    if( p->selFlags & SF_Converted ){
      Select *pSub = p->pSrc->a[0].pSelect;
      assert( p->pSrc->nSrc==1 && p->pOrderBy );
      assert( pSub->pPrior && pSub->pOrderBy==0 );
      pSub->pOrderBy = p->pOrderBy;
      p->pOrderBy = 0;
    }

    /* Recursively resolve names in all subqueries
    */
    for(i=0; i<p->pSrc->nSrc; i++){
      struct SrcList_item *pItem = &p->pSrc->a[i];
      if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
        NameContext *pNC;         /* Used to iterate name contexts */
        int nRef = 0;             /* Refcount for pOuterNC and outer contexts */
        const char *zSavedContext = pParse->zAuthContext;

        /* Count the total number of references to pOuterNC and all of its
        ** parent contexts. After resolving references to expressions in
        ** pItem->pSelect, check if this value has changed. If so, then
        ** SELECT statement pItem->pSelect must be correlated. Set the
        ** pItem->fg.isCorrelated flag if this is the case. */
        for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;

        if( pItem->zName ) pParse->zAuthContext = pItem->zName;
        sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
        pParse->zAuthContext = zSavedContext;
        if( pParse->nErr || db->mallocFailed ) return WRC_Abort;

        for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
        assert( pItem->fg.isCorrelated==0 && nRef<=0 );
        pItem->fg.isCorrelated = (nRef!=0);
      }
    }

    /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
    ** resolve the result-set expression list.
    */
    sNC.ncFlags = NC_AllowAgg|NC_AllowWin;
    sNC.pSrcList = p->pSrc;
    sNC.pNext = pOuterNC;

    /* Resolve names in the result set. */
    if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
    sNC.ncFlags &= ~NC_AllowWin;

    /* If there are no aggregate functions in the result-set, and no GROUP BY
    ** expression, do not allow aggregates in any of the other expressions.
    */
    assert( (p->selFlags & SF_Aggregate)==0 );
    pGroupBy = p->pGroupBy;
    if( pGroupBy || (sNC.ncFlags & NC_HasAgg)!=0 ){
      assert( NC_MinMaxAgg==SF_MinMaxAgg );
      p->selFlags |= SF_Aggregate | (sNC.ncFlags&NC_MinMaxAgg);
    }else{
      sNC.ncFlags &= ~NC_AllowAgg;
    }

    /* If a HAVING clause is present, then there must be a GROUP BY clause.
    */
    if( p->pHaving && !pGroupBy ){
      sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
      return WRC_Abort;
    }

    /* Add the output column list to the name-context before parsing the
    ** other expressions in the SELECT statement. This is so that
    ** expressions in the WHERE clause (etc.) can refer to expressions by
    ** aliases in the result set.
    **
    ** Minor point: If this is the case, then the expression will be
    ** re-evaluated for each reference to it.
    */
    assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert))==0 );
    sNC.uNC.pEList = p->pEList;
    sNC.ncFlags |= NC_UEList;
    if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
    if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;

    /* Resolve names in table-valued-function arguments */
    for(i=0; i<p->pSrc->nSrc; i++){
      struct SrcList_item *pItem = &p->pSrc->a[i];
      if( pItem->fg.isTabFunc
       && sqlite3ResolveExprListNames(&sNC, pItem->u1.pFuncArg)
      ){
        return WRC_Abort;
      }
    }

    /* The ORDER BY and GROUP BY clauses may not refer to terms in
    ** outer queries
    */
    sNC.pNext = 0;
    sNC.ncFlags |= NC_AllowAgg|NC_AllowWin;

    /* If this is a converted compound query, move the ORDER BY clause from
    ** the sub-query back to the parent query. At this point each term
    ** within the ORDER BY clause has been transformed to an integer value.
    ** These integers will be replaced by copies of the corresponding result
    ** set expressions by the call to resolveOrderGroupBy() below.  */
    if( p->selFlags & SF_Converted ){
      Select *pSub = p->pSrc->a[0].pSelect;
      p->pOrderBy = pSub->pOrderBy;
      pSub->pOrderBy = 0;
    }

    /* Process the ORDER BY clause for singleton SELECT statements.
    ** The ORDER BY clause for compounds SELECT statements is handled
    ** below, after all of the result-sets for all of the elements of
    ** the compound have been resolved.
    **
    ** If there is an ORDER BY clause on a term of a compound-select other
    ** than the right-most term, then that is a syntax error.  But the error
    ** is not detected until much later, and so we need to go ahead and
    ** resolve those symbols on the incorrect ORDER BY for consistency.
    */
    if( isCompound<=nCompound  /* Defer right-most ORDER BY of a compound */
     && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER")
    ){
      return WRC_Abort;
    }
    if( db->mallocFailed ){
      return WRC_Abort;
    }
    sNC.ncFlags &= ~NC_AllowWin;

    /* Resolve the GROUP BY clause.  At the same time, make sure
    ** the GROUP BY clause does not contain aggregate functions.
    */
    if( pGroupBy ){
      struct ExprList_item *pItem;

      if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
        return WRC_Abort;
      }
      for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
        if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
          sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
              "the GROUP BY clause");
          return WRC_Abort;
        }
      }
    }

#ifndef SQLITE_OMIT_WINDOWFUNC
    if( IN_RENAME_OBJECT ){
      Window *pWin;
      for(pWin=p->pWinDefn; pWin; pWin=pWin->pNextWin){
        if( sqlite3ResolveExprListNames(&sNC, pWin->pOrderBy)
         || sqlite3ResolveExprListNames(&sNC, pWin->pPartition)
        ){
          return WRC_Abort;
        }
      }
    }
#endif

    /* If this is part of a compound SELECT, check that it has the right
    ** number of expressions in the select list. */
    if( p->pNext && p->pEList->nExpr!=p->pNext->pEList->nExpr ){
      sqlite3SelectWrongNumTermsError(pParse, p->pNext);
      return WRC_Abort;
    }

    /* Advance to the next term of the compound
    */
    p = p->pPrior;
    nCompound++;
  }

  /* Resolve the ORDER BY on a compound SELECT after all terms of
  ** the compound have been resolved.
  */
  if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
    return WRC_Abort;
  }

  return WRC_Prune;
}

// Assembly:
movl 0x4(%rsi), %ecx
pushq $0x1
popq %rax
testb $0x4, %cl
jne 0x26cb6d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r12
movq (%rdi), %r8
movq 0x28(%rdi), %rdx
movq (%r8), %rax
movq %rax, 0x10(%rsp)
pushq $0x2
popq %rbx
testb $0x40, %cl
jne 0x26c7be
movq %r8, %rdi
movq %r12, %rsi
movq %r8, %r14
callq 0x26d3a5
cmpl $0x0, 0x30(%r14)
movl %ebx, %eax
jne 0x26cb5c
movq 0x10(%rsp), %rax
cmpb $0x1, 0x61(%rax)
pushq $0x2
popq %rax
sbbl $0x0, %eax
jmp 0x26cb5c
movq %rdx, 0x38(%rsp)
movq 0x50(%r12), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rax
leaq 0x48(%rsp), %r15
movl $0x0, 0x20(%rsp)
movq %r12, %r14
movq %r8, 0x8(%rsp)
movq %r12, 0x30(%rsp)
testq %r14, %r14
je 0x26cb6e
orb $0x4, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movups %xmm0, (%rax)
movq %r8, 0x48(%rsp)
movq %r14, 0x78(%rsp)
movq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x26afc4
testl %eax, %eax
jne 0x26cb59
testb $0x1, 0x6(%r14)
je 0x26c843
movq 0x28(%r14), %rax
movq 0x48(%r14), %rcx
movq 0x30(%rax), %rax
movq %rcx, 0x48(%rax)
andq $0x0, 0x48(%r14)
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq 0x28(%r14), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jge 0x26c90d
imulq $0x70, %r12, %rcx
movq 0x30(%rax,%rcx), %rsi
testq %rsi, %rsi
je 0x26c905
testb $0x4, 0x4(%rsi)
jne 0x26c905
leaq (%rax,%rcx), %rbp
addq $0x8, %rbp
movq 0x160(%rdi), %rbx
xorl %r13d, %r13d
movq %rdx, %rax
testq %rax, %rax
je 0x26c8a0
addl 0x20(%rax), %r13d
movq 0x18(%rax), %rax
jmp 0x26c891
movq 0x10(%rbp), %rax
testq %rax, %rax
je 0x26c8b0
movq %rax, 0x160(%rdi)
callq 0x26d490
movq 0x8(%rsp), %rdi
movq %rbx, 0x160(%rdi)
cmpl $0x0, 0x30(%rdi)
jne 0x26cb59
movq 0x10(%rsp), %rax
cmpb $0x0, 0x61(%rax)
jne 0x26cb59
movq 0x38(%rsp), %rdx
movq %rdx, %rax
testq %rax, %rax
je 0x26c8f1
subl 0x20(%rax), %r13d
movq 0x18(%rax), %rax
jmp 0x26c8e2
testl %r13d, %r13d
setne %al
movb 0x3d(%rbp), %cl
shlb $0x3, %al
andb $-0x9, %cl
orb %al, %cl
movb %cl, 0x3d(%rbp)
incq %r12
jmp 0x26c850
movl $0x4001, 0x70(%rsp)     # imm = 0x4001
movq %rax, 0x50(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x26b08f
testl %eax, %eax
jne 0x26cb59
movl 0x70(%rsp), %ecx
movl %ecx, %eax
andl $0xffffbfff, %eax       # imm = 0xFFFFBFFF
movl %eax, 0x70(%rsp)
movq 0x38(%r14), %r12
testq %r12, %r12
setne %dl
movl %ecx, %esi
andl $0x10, %esi
shrl $0x4, %esi
orb %dl, %sil
cmpb $0x1, %sil
jne 0x26c970
andl $0x1000, %ecx           # imm = 0x1000
orl 0x4(%r14), %ecx
orl $0x8, %ecx
movl %ecx, 0x4(%r14)
jmp 0x26c97c
andl $0xffffbfee, %ecx       # imm = 0xFFFFBFEE
movl %ecx, 0x70(%rsp)
movl %ecx, %eax
movq 0x8(%rsp), %rdi
testq %r12, %r12
setne %cl
movq 0x40(%r14), %rsi
testq %rsi, %rsi
sete %dl
orb %cl, %dl
je 0x26cb99
movq 0x20(%r14), %rcx
movq %rcx, 0x58(%rsp)
orl $0x80, %eax
movl %eax, 0x70(%rsp)
movq %r15, %rdi
callq 0x26afc4
testl %eax, %eax
jne 0x26cb59
movq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x26afc4
testl %eax, %eax
jne 0x26cb59
pushq $0x68
popq %r13
xorl %ebx, %ebx
movq 0x28(%r14), %rax
movslq (%rax), %rcx
cmpq %rcx, %rbx
jge 0x26ca06
testb $0x4, -0x23(%rax,%r13)
je 0x26c9fd
movq (%rax,%r13), %rsi
movq %r15, %rdi
callq 0x26b08f
testl %eax, %eax
jne 0x26cb59
incq %rbx
addq $0x70, %r13
jmp 0x26c9d5
andq $0x0, 0x60(%rsp)
orl $0x4001, 0x70(%rsp)     # imm = 0x4001
testb $0x1, 0x6(%r14)
je 0x26ca2c
movq 0x30(%rax), %rax
movq 0x48(%rax), %rcx
movq %rcx, 0x48(%r14)
andq $0x0, 0x48(%rax)
cmpq $0x0, 0x18(%rsp)
setne %al
cmpl $0x0, 0x20(%rsp)
sete %cl
testb %cl, %al
jne 0x26ca5f
movq 0x48(%r14), %rdx
movq %r15, %rdi
movq %r14, %rsi
leaq 0x10b671(%rip), %rcx    # 0x3780c3
callq 0x26d4c8
testl %eax, %eax
jne 0x26cb59
movq 0x10(%rsp), %rax
cmpb $0x0, 0x61(%rax)
jne 0x26cb59
andb $-0x41, 0x71(%rsp)
testq %r12, %r12
movq 0x8(%rsp), %r8
je 0x26cad5
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
leaq 0x10b63c(%rip), %rcx    # 0x3780c9
callq 0x26d4c8
testl %eax, %eax
jne 0x26cb59
movq 0x10(%rsp), %rax
cmpb $0x0, 0x61(%rax)
jne 0x26cb59
movl (%r12), %eax
addq $0x8, %r12
testl %eax, %eax
movl $0x0, %ecx
cmovlel %ecx, %eax
movq 0x8(%rsp), %r8
subl $0x1, %eax
jb 0x26cad5
movq (%r12), %rcx
testb $0x10, 0x4(%rcx)
jne 0x26cb48
addq $0x18, %r12
jmp 0x26cac0
cmpb $0x2, 0x11c(%r8)
movq 0x30(%rsp), %r12
jb 0x26cb1b
leaq 0x78(%r14), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x26cb1b
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x26b08f
testl %eax, %eax
jne 0x26cb59
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x26b08f
addq $0x40, %rbx
testl %eax, %eax
movq 0x8(%rsp), %r8
je 0x26cae8
jmp 0x26cb59
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x26cb36
movq 0x20(%r14), %rcx
movl (%rcx), %ecx
movq 0x20(%rax), %rdx
cmpl (%rdx), %ecx
jne 0x26ce9f
movq 0x50(%r14), %r14
incl 0x20(%rsp)
leaq 0x50(%rsp), %rax
jmp 0x26c7ec
leaq 0x10b580(%rip), %rsi    # 0x3780cf
movq %r8, %rdi
xorl %eax, %eax
callq 0x226dce
pushq $0x2
popq %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x18(%rsp)
je 0x26cba2
movq 0x48(%r12), %rdi
testq %rdi, %rdi
pushq $0x1
popq %rax
je 0x26cb5c
movq (%r8), %rbx
movl (%rdi), %eax
cmpl 0x84(%rbx), %eax
jle 0x26cba6
leaq 0x10b8d4(%rip), %rsi    # 0x37846b
jmp 0x26cb4f
leaq 0x10b4f7(%rip), %rsi    # 0x378097
jmp 0x26cb52
pushq $0x1
jmp 0x26cb5b
leaq 0x8(%rdi), %rcx
movq %rcx, 0x88(%rsp)
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
imulq $0x18, %rdx, %rdx
cmpq %rcx, %rdx
je 0x26cbd2
andb $-0x5, 0x19(%rdi,%rcx)
addq $0x18, %rcx
jmp 0x26cbc2
xorl %r14d, %r14d
movq %r14, %rcx
movq %r12, %r14
movq %rcx, 0x58(%r12)
movq 0x50(%r12), %r12
testq %r12, %r12
jne 0x26cbd5
pushq $0x1
popq %rcx
movq %rdi, 0x40(%rsp)
movq %rbx, 0x80(%rsp)
testq %r14, %r14
je 0x26ceeb
testl %ecx, %ecx
je 0x26ceeb
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rsp)
xorl %r13d, %r13d
xorl %ecx, %ecx
movq 0x88(%rsp), %r12
cmpl %eax, %r13d
jge 0x26ce7c
orl $-0x1, 0x2c(%rsp)
testb $0x4, 0x11(%r12)
jne 0x26ce6e
movq %rdi, %rbp
movl %ecx, 0x38(%rsp)
movq (%r12), %rdi
callq 0x267d34
movq %rax, %r15
movq %rax, %rdi
leaq 0x2c(%rsp), %rsi
callq 0x26f334
testl %eax, %eax
movq %r15, 0x10(%rsp)
je 0x26cc8f
movl 0x2c(%rsp), %r15d
movq 0x20(%rsp), %rax
movl (%rax), %ecx
testl %r15d, %r15d
movq 0x8(%rsp), %r8
jle 0x26ce85
movq %rbp, %rdi
cmpl %ecx, %r15d
jle 0x26cdfb
jmp 0x26ce85
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x26f2cf
movl %eax, %r15d
testl %eax, %eax
movq 0x8(%rsp), %r8
movq %rbp, %rdi
jne 0x26cdf3
movb 0x11c(%r8), %al
movq 0x10(%rsp), %rsi
movq %rsi, 0x18(%rsp)
cmpb $0x1, %al
ja 0x26cce2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x267197
movq %rbp, %rdi
movq 0x8(%rsp), %r8
movq %rax, 0x18(%rsp)
movb 0x11c(%r8), %al
xorl %r15d, %r15d
cmpb $0x0, 0x61(%rbx)
jne 0x26cdd1
movq 0x20(%r14), %rdx
leaq 0xa8(%rsp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rcx)
movups %xmm0, (%rcx)
movq %r8, 0x90(%rsp)
movq 0x28(%r14), %rcx
movq %rcx, 0x98(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdx, 0xa0(%rsp)
movl $0x81, 0xb8(%rsp)
movq (%r8), %r15
movb 0x65(%r15), %bpl
cmpb $0x1, %al
ja 0x26cd41
movb $0x1, 0x65(%r15)
leaq 0x90(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x26afc4
movb %bpl, 0x65(%r15)
xorl %r15d, %r15d
testl %eax, %eax
je 0x26cd65
movq 0x40(%rsp), %rdi
jmp 0x26cdbd
movl %r13d, 0x28(%rsp)
movq 0x30(%rsp), %rax
leaq 0x8(%rax), %rbp
xorl %r13d, %r13d
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %r13
jge 0x26cdb8
movq %rdi, %rbx
movq (%rbp), %rsi
xorl %edi, %edi
movq 0x18(%rsp), %rdx
pushq $-0x1
popq %rcx
callq 0x26823c
cmpl $0x1, %eax
jbe 0x26cdaf
incq %r13
addq $0x18, %rbp
movq %rbx, %rdi
jmp 0x26cd7b
incl %r13d
movl %r13d, %r15d
movq %rbx, %rdi
movl 0x28(%rsp), %r13d
movq 0x8(%rsp), %r8
movb 0x11c(%r8), %al
movq 0x80(%rsp), %rbx
cmpb $0x1, %al
ja 0x26cdf3
movq %rbx, %rbp
movq %rdi, %rbx
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
callq 0x24b639
movq %rbx, %rdi
movq %rbp, %rbx
movq 0x8(%rsp), %r8
pushq $0x1
popq %rcx
testl %r15d, %r15d
jle 0x26ce6e
cmpb $0x1, 0x11c(%r8)
ja 0x26ce64
movq %rdi, %rbp
movq %rbx, %rdi
movl $0x98, %esi
xorl %edx, %edx
callq 0x25bd93
testq %rax, %rax
je 0x26cb59
orb $0x4, 0x5(%rax)
movl %r15d, 0x8(%rax)
movq (%r12), %rdx
movq %r12, %rcx
cmpq 0x10(%rsp), %rdx
je 0x26ce46
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
cmpb $0x6f, (%rdx)
je 0x26ce36
addq $0x10, %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x24b639
movw %r15w, 0x14(%r12)
movq 0x8(%rsp), %r8
movq %rbp, %rdi
orb $0x4, 0x11(%r12)
movl 0x38(%rsp), %ecx
incl %r13d
addq $0x18, %r12
movl (%rdi), %eax
jmp 0x26cc21
movq 0x58(%r14), %r14
jmp 0x26cbfa
incl %r13d
leaq 0x10b234(%rip), %rsi    # 0x3780c3
movq %r8, %rdi
movl %r13d, %edx
callq 0x26f38e
jmp 0x26cb59
testb $0x2, 0x5(%rax)
jne 0x26cec0
movb (%rax), %al
addb $0x7b, %al
cmpb $0x2, %al
pushq $0x2
popq %rbx
ja 0x26cecc
movzbl %al, %eax
leaq 0x1ca41e(%rip), %rcx    # 0x4372d8
movq (%rcx,%rax,8), %rdx
jmp 0x26ced3
leaq 0x10b503(%rip), %rsi    # 0x3783ca
jmp 0x26cb4f
leaq 0x10b592(%rip), %rdx    # 0x378465
leaq 0x10b51e(%rip), %rsi    # 0x3783f8
movq %r8, %rdi
xorl %eax, %eax
callq 0x226dce
movl %ebx, %eax
jmp 0x26cb5c
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
imulq $0x18, %rax, %rsi
pushq $0x1
popq %rax
movl %eax, %edx
cmpq %rcx, %rsi
je 0x26cb5c
testb $0x4, 0x19(%rdi,%rcx)
je 0x26cf13
incl %edx
addq $0x18, %rcx
jmp 0x26cefb
leaq 0x10b573(%rip), %rsi    # 0x37848d
movq %r8, %rdi
xorl %eax, %eax
callq 0x226dce
jmp 0x26cb59