// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: resolveExprStep
static int resolveExprStep(Walker *pWalker, Expr *pExpr){
  NameContext *pNC;
  Parse *pParse;

  pNC = pWalker->u.pNC;
  assert( pNC!=0 );
  pParse = pNC->pParse;
  assert( pParse==pWalker->pParse );

#ifndef NDEBUG
  if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
    SrcList *pSrcList = pNC->pSrcList;
    int i;
    for(i=0; i<pNC->pSrcList->nSrc; i++){
      assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
    }
  }
#endif
  switch( pExpr->op ){

#if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
    /* The special operator TK_ROW means use the rowid for the first
    ** column in the FROM clause.  This is used by the LIMIT and ORDER BY
    ** clause processing on UPDATE and DELETE statements.
    */
    case TK_ROW: {
      SrcList *pSrcList = pNC->pSrcList;
      struct SrcList_item *pItem;
      assert( pSrcList && pSrcList->nSrc==1 );
      pItem = pSrcList->a;
      assert( HasRowid(pItem->pTab) && pItem->pTab->pSelect==0 );
      pExpr->op = TK_COLUMN;
      pExpr->pTab = pItem->pTab;
      pExpr->iTable = pItem->iCursor;
      pExpr->iColumn = -1;
      pExpr->affinity = SQLITE_AFF_INTEGER;
      break;
    }
#endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
          && !defined(SQLITE_OMIT_SUBQUERY) */

    /* A column name:                    ID
    ** Or table name and column name:    ID.ID
    ** Or a database, table and column:  ID.ID.ID
    **
    ** The TK_ID and TK_OUT cases are combined so that there will only
    ** be one call to lookupName().  Then the compiler will in-line 
    ** lookupName() for a size reduction and performance increase.
    */
    case TK_ID:
    case TK_DOT: {
      const char *zColumn;
      const char *zTable;
      const char *zDb;
      Expr *pRight;

      if( pExpr->op==TK_ID ){
        zDb = 0;
        zTable = 0;
        zColumn = pExpr->u.zToken;
      }else{
        Expr *pLeft = pExpr->pLeft;
        notValid(pParse, pNC, "the \".\" operator", NC_IdxExpr);
        pRight = pExpr->pRight;
        if( pRight->op==TK_ID ){
          zDb = 0;
        }else{
          assert( pRight->op==TK_DOT );
          zDb = pLeft->u.zToken;
          pLeft = pRight->pLeft;
          pRight = pRight->pRight;
        }
        zTable = pLeft->u.zToken;
        zColumn = pRight->u.zToken;
        if( IN_RENAME_OBJECT ){
          sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
        }
        if( IN_RENAME_OBJECT ){
          sqlite3RenameTokenRemap(pParse, (void*)&pExpr->pTab, (void*)pLeft);
        }
      }
      return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
    }

    /* Resolve function names
    */
    case TK_FUNCTION: {
      ExprList *pList = pExpr->x.pList;    /* The argument list */
      int n = pList ? pList->nExpr : 0;    /* Number of arguments */
      int no_such_func = 0;       /* True if no such function exists */
      int wrong_num_args = 0;     /* True if wrong number of arguments */
      int is_agg = 0;             /* True if is an aggregate function */
      int nId;                    /* Number of characters in function name */
      const char *zId;            /* The function name. */
      FuncDef *pDef;              /* Information about the function */
      u8 enc = ENC(pParse->db);   /* The database encoding */

      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      zId = pExpr->u.zToken;
      nId = sqlite3Strlen30(zId);
      pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
      if( pDef==0 ){
        pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
        if( pDef==0 ){
          no_such_func = 1;
        }else{
          wrong_num_args = 1;
        }
      }else{
        is_agg = pDef->xFinalize!=0;
        if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
          ExprSetProperty(pExpr, EP_Unlikely|EP_Skip);
          if( n==2 ){
            pExpr->iTable = exprProbability(pList->a[1].pExpr);
            if( pExpr->iTable<0 ){
              sqlite3ErrorMsg(pParse,
                "second argument to likelihood() must be a "
                "constant between 0.0 and 1.0");
              pNC->nErr++;
            }
          }else{
            /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
            ** equivalent to likelihood(X, 0.0625).
            ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
            ** short-hand for likelihood(X,0.0625).
            ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
            ** for likelihood(X,0.9375).
            ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
            ** to likelihood(X,0.9375). */
            /* TUNING: unlikely() probability is 0.0625.  likely() is 0.9375 */
            pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
          }             
        }
#ifndef SQLITE_OMIT_AUTHORIZATION
        {
          int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
          if( auth!=SQLITE_OK ){
            if( auth==SQLITE_DENY ){
              sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
                                      pDef->zName);
              pNC->nErr++;
            }
            pExpr->op = TK_NULL;
            return WRC_Prune;
          }
        }
#endif
        if( pDef->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG) ){
          /* For the purposes of the EP_ConstFunc flag, date and time
          ** functions and other functions that change slowly are considered
          ** constant because they are constant for the duration of one query */
          ExprSetProperty(pExpr,EP_ConstFunc);
        }
        if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
          /* Date/time functions that use 'now', and other functions like
          ** sqlite_version() that might change over time cannot be used
          ** in an index. */
          notValid(pParse, pNC, "non-deterministic functions",
                   NC_IdxExpr|NC_PartIdx);
        }
      }

      if( 0==IN_RENAME_OBJECT ){
#ifndef SQLITE_OMIT_WINDOWFUNC
        assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
          || (pDef->xValue==0 && pDef->xInverse==0)
          || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
        );
        if( pDef && pDef->xValue==0 && pExpr->pWin ){
          sqlite3ErrorMsg(pParse, 
              "%.*s() may not be used as a window function", nId, zId
          );
          pNC->nErr++;
        }else if( 
              (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
           || (is_agg && (pDef->funcFlags & SQLITE_FUNC_WINDOW) && !pExpr->pWin)
           || (is_agg && pExpr->pWin && (pNC->ncFlags & NC_AllowWin)==0)
        ){
          const char *zType;
          if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pExpr->pWin ){
            zType = "window";
          }else{
            zType = "aggregate";
          }
          sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
          pNC->nErr++;
          is_agg = 0;
        }
#else
        if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
          sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
          pNC->nErr++;
          is_agg = 0;
        }
#endif
        else if( no_such_func && pParse->db->init.busy==0
#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
                  && pParse->explain==0
#endif
        ){
          sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
          pNC->nErr++;
        }else if( wrong_num_args ){
          sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
               nId, zId);
          pNC->nErr++;
        }
        if( is_agg ){
#ifndef SQLITE_OMIT_WINDOWFUNC
          pNC->ncFlags &= ~(pExpr->pWin ? NC_AllowWin : NC_AllowAgg);
#else
          pNC->ncFlags &= ~NC_AllowAgg;
#endif
        }
      }
      sqlite3WalkExprList(pWalker, pList);
      if( is_agg ){
#ifndef SQLITE_OMIT_WINDOWFUNC
        if( pExpr->pWin ){
          Select *pSel = pNC->pWinSelect;
          sqlite3WalkExprList(pWalker, pExpr->pWin->pPartition);
          sqlite3WalkExprList(pWalker, pExpr->pWin->pOrderBy);
          sqlite3WalkExpr(pWalker, pExpr->pWin->pFilter);
          sqlite3WindowUpdate(pParse, pSel->pWinDefn, pExpr->pWin, pDef);
          if( 0==pSel->pWin 
           || 0==sqlite3WindowCompare(pParse, pSel->pWin, pExpr->pWin) 
          ){
            pExpr->pWin->pNextWin = pSel->pWin;
            pSel->pWin = pExpr->pWin;
          }
          pNC->ncFlags |= NC_AllowWin;
        }else
#endif /* SQLITE_OMIT_WINDOWFUNC */
        {
          NameContext *pNC2 = pNC;
          pExpr->op = TK_AGG_FUNCTION;
          pExpr->op2 = 0;
          while( pNC2 && !sqlite3FunctionUsesThisSrc(pExpr, pNC2->pSrcList) ){
            pExpr->op2++;
            pNC2 = pNC2->pNext;
          }
          assert( pDef!=0 );
          if( pNC2 ){
            assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
            testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
            pNC2->ncFlags |= NC_HasAgg | (pDef->funcFlags & SQLITE_FUNC_MINMAX);

          }
          pNC->ncFlags |= NC_AllowAgg;
        }
      }
      /* FIX ME:  Compute pExpr->affinity based on the expected return
      ** type of the function 
      */
      return WRC_Prune;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_SELECT:
    case TK_EXISTS:  testcase( pExpr->op==TK_EXISTS );
#endif
    case TK_IN: {
      testcase( pExpr->op==TK_IN );
      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        int nRef = pNC->nRef;
        notValid(pParse, pNC, "subqueries", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
        sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
        assert( pNC->nRef>=nRef );
        if( nRef!=pNC->nRef ){
          ExprSetProperty(pExpr, EP_VarSelect);
          pNC->ncFlags |= NC_VarSelect;
        }
      }
      break;
    }
    case TK_VARIABLE: {
      notValid(pParse, pNC, "parameters", NC_IsCheck|NC_PartIdx|NC_IdxExpr);
      break;
    }
    case TK_IS:
    case TK_ISNOT: {
      Expr *pRight;
      assert( !ExprHasProperty(pExpr, EP_Reduced) );
      /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
      ** and "x IS NOT FALSE". */
      if( (pRight = pExpr->pRight)->op==TK_ID ){
        int rc = resolveExprStep(pWalker, pRight);
        if( rc==WRC_Abort ) return WRC_Abort;
        if( pRight->op==TK_TRUEFALSE ){
          pExpr->op2 = pExpr->op;
          pExpr->op = TK_TRUTH;
          return WRC_Continue;
        }
      }
      /* Fall thru */
    }
    case TK_BETWEEN:
    case TK_EQ:
    case TK_NE:
    case TK_LT:
    case TK_LE:
    case TK_GT:
    case TK_GE: {
      int nLeft, nRight;
      if( pParse->db->mallocFailed ) break;
      assert( pExpr->pLeft!=0 );
      nLeft = sqlite3ExprVectorSize(pExpr->pLeft);
      if( pExpr->op==TK_BETWEEN ){
        nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[0].pExpr);
        if( nRight==nLeft ){
          nRight = sqlite3ExprVectorSize(pExpr->x.pList->a[1].pExpr);
        }
      }else{
        assert( pExpr->pRight!=0 );
        nRight = sqlite3ExprVectorSize(pExpr->pRight);
      }
      if( nLeft!=nRight ){
        testcase( pExpr->op==TK_EQ );
        testcase( pExpr->op==TK_NE );
        testcase( pExpr->op==TK_LT );
        testcase( pExpr->op==TK_LE );
        testcase( pExpr->op==TK_GT );
        testcase( pExpr->op==TK_GE );
        testcase( pExpr->op==TK_IS );
        testcase( pExpr->op==TK_ISNOT );
        testcase( pExpr->op==TK_BETWEEN );
        sqlite3ErrorMsg(pParse, "row value misused");
      }
      break; 
    }
  }
  return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r15
movq 0x28(%rdi), %rdx
movq (%rdx), %r13
movq %rsi, 0x8(%rsp)
movzbl (%rsi), %eax
cmpl $0x7e, %eax
jg 0x454899
leal -0x2d(%rax), %ecx
cmpl $0xe, %ecx
ja 0x454a3c
leaq 0xf7991(%rip), %rax     # 0x54c1dc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%r13), %rax
cmpb $0x0, 0x61(%rax)
jne 0x454ba0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movb (%rcx), %al
cmpb $-0x5c, %al
jne 0x454874
movb 0x36(%rcx), %al
cmpb $0x7f, %al
je 0x454a9f
movzbl %al, %edx
movl $0x1, %eax
cmpl $0xa5, %edx
jne 0x454aa8
addq $0x20, %rcx
jmp 0x454aa3
cmpl $0x8f, %eax
jle 0x4549a5
cmpl $0x90, %eax
je 0x454b33
cmpl $0x9c, %eax
je 0x4549f2
cmpl $0x9d, %eax
jne 0x454ba0
movq %rdx, 0x28(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %r14
xorl %ecx, %ecx
movl $0x0, %ebx
testq %r14, %r14
je 0x4548e2
movl (%r14), %ebx
movq %r13, 0x18(%rsp)
movq (%r13), %r12
movb 0x5e(%r12), %bpl
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x45490f
movq %r13, %rdi
callq 0x401100
movq %rax, %rcx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movq %rcx, 0x20(%rsp)
movzbl %bpl, %ebp
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x413494
testq %rax, %rax
je 0x454c17
movq %rax, %r12
movq 0x20(%rax), %rbp
testq %rbp, %rbp
setne %al
movq %rax, 0x38(%rsp)
testb $0x4, 0x5(%r12)
je 0x454cba
movq %r14, %rdx
movq 0x8(%rsp), %r14
orl $0x41000, 0x4(%r14)     # imm = 0x41000
cmpl $0x2, %ebx
jne 0x454c9e
movq %rdx, %rbx
movq 0x28(%rdx), %rdi
callq 0x455f77
movl %eax, 0x2c(%r14)
movq %rbx, %r14
testl %eax, %eax
jns 0x454cba
leaq 0xfdc73(%rip), %rsi     # 0x5525ff
movq 0x18(%rsp), %rdi
xorl %eax, %eax
callq 0x40e48a
movq 0x28(%rsp), %rax
incl 0x24(%rax)
jmp 0x454cba
cmpl $0x7f, %eax
je 0x454a45
cmpl $0x82, %eax
jne 0x454ba0
movq 0x8(%rsp), %r14
movq 0x10(%r14), %rbx
movq %rdx, 0x28(%rsp)
movl 0x28(%rdx), %esi
leaq 0xfdc1d(%rip), %rdx     # 0x5525ee
movq %r13, %rdi
movl $0x20, %ecx
callq 0x455f40
movq 0x18(%r14), %rax
cmpb $0x3b, (%rax)
jne 0x454bcd
xorl %ebp, %ebp
jmp 0x454bd9
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rbx
cmpb $0x3b, (%rbx)
jne 0x454854
movq %r15, %rdi
movq %rbx, %rsi
callq 0x454810
movl %eax, %ecx
movl $0x2, %eax
cmpl $0x2, %ecx
je 0x454bbb
cmpb $-0x65, (%rbx)
jne 0x454854
movq 0x8(%rsp), %rcx
movb (%rcx), %al
movb %al, 0x36(%rcx)
movb $-0x5d, (%rcx)
xorl %eax, %eax
jmp 0x454bbb
cmpl $0x14, %eax
jne 0x454ba0
movq 0x8(%rsp), %rax
testb $0x8, 0x5(%rax)
je 0x454ba0
movq %rdx, %r14
movl 0x20(%rdx), %ebx
movl 0x28(%rdx), %esi
leaq 0xfdcbf(%rip), %rdx     # 0x552723
movq %r13, %rdi
movl $0x26, %ecx
callq 0x455f40
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
movq %r15, %rdi
callq 0x451d36
cmpl 0x20(%r14), %ebx
je 0x454ba0
movq 0x8(%rsp), %rax
orb $0x20, 0x4(%rax)
orb $0x40, 0x28(%r14)
jmp 0x454ba0
movq 0x20(%rcx), %rcx
movq (%rcx), %rax
movl (%rax), %eax
movq 0x8(%rsp), %rcx
cmpb $0x30, (%rcx)
jne 0x454ae4
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %rdx
movb (%rdx), %sil
cmpb $-0x5c, %sil
jne 0x454ac7
movb 0x36(%rdx), %sil
cmpb $0x7f, %sil
je 0x454b4c
movzbl %sil, %edi
movl $0x1, %esi
cmpl $0xa5, %edi
jne 0x454b55
addq $0x20, %rdx
jmp 0x454b50
movq 0x18(%rcx), %rcx
jmp 0x454b5d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq (%r13), %rcx
movq %rcx, 0x88(%rsp)
leaq 0x2c(%rax), %rcx
movq %rcx, 0x68(%rsp)
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
leaq 0x40(%rax), %rcx
movq %rcx, 0x90(%rsp)
movq $0x0, 0x40(%rax)
xorl %r8d, %r8d
xorl %r15d, %r15d
jmp 0x454e1f
movl 0x28(%rdx), %esi
leaq 0xfdbf1(%rip), %rdx     # 0x55272e
movq %r13, %rdi
movl $0x26, %ecx
callq 0x455f40
jmp 0x454ba0
movq 0x20(%rdx), %rdx
movq (%rdx), %rdx
movl (%rdx), %esi
cmpl %eax, %esi
jne 0x454b8b
movq 0x28(%rcx), %rcx
movb (%rcx), %dl
cmpb $-0x5c, %dl
jne 0x454b67
movb 0x36(%rcx), %dl
cmpb $0x7f, %dl
je 0x454b82
movzbl %dl, %edx
movl $0x1, %esi
cmpl $0xa5, %edx
jne 0x454b8b
addq $0x20, %rcx
jmp 0x454b86
movq 0x20(%rcx), %rcx
movq (%rcx), %rcx
movl (%rcx), %esi
cmpl %esi, %eax
je 0x454ba0
leaq 0xfd74f(%rip), %rsi     # 0x5522e5
movq %r13, %rdi
xorl %eax, %eax
callq 0x40e48a
movl $0x2, %eax
cmpl $0x0, 0x30(%r13)
jne 0x454bbb
movq (%r13), %rcx
xorl %eax, %eax
cmpb $0x0, 0x61(%rcx)
setne %al
addl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rbp
movq 0x10(%rax), %rbx
movq 0x18(%rax), %rax
movq 0x8(%rbx), %r12
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
cmpb $0x2, 0x10c(%r13)
jb 0x454dc6
movq 0x190(%r13), %rcx
testq %rcx, %rcx
je 0x454dc6
movq %rcx, %rdx
cmpq %rax, (%rdx)
je 0x454c66
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
jne 0x454c07
jmp 0x454c75
movq 0x18(%rsp), %rbx
movq (%rbx), %rdi
movq %r13, %rsi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x413494
cmpb $0x2, 0x10c(%rbx)
jae 0x454c5b
movq %rax, %r12
movq %r14, %rbx
xorl %ebp, %ebp
testq %rax, %rax
sete %al
setne %cl
je 0x4556cb
movq 0x28(%rsp), %r14
jmp 0x454d5d
movq %r15, %rdi
movq %r14, %rsi
jmp 0x455abc
movq 0x8(%rsp), %rax
movq %rax, (%rdx)
movq 0x190(%r13), %rcx
testq %rcx, %rcx
je 0x454dc6
movq 0x8(%rsp), %rax
addq $0x40, %rax
cmpq %rbx, (%rcx)
je 0x454dc3
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x454c87
jmp 0x454dc6
movq 0x38(%r12), %rax
cmpb $0x75, (%rax)
movl $0x800000, %eax         # imm = 0x800000
movl $0x7800000, %ecx        # imm = 0x7800000
cmovel %eax, %ecx
movl %ecx, 0x2c(%r14)
movq %rdx, %r14
movq 0x38(%r12), %rcx
movq 0x18(%rsp), %rdi
movl $0x1f, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x453d2a
testl %eax, %eax
je 0x454d09
cmpl $0x1, %eax
jne 0x454cfc
movq 0x38(%r12), %rdx
leaq 0xfd95e(%rip), %rsi     # 0x552646
movq 0x18(%rsp), %rdi
xorl %eax, %eax
callq 0x40e48a
movq 0x28(%rsp), %rax
incl 0x24(%rax)
movq 0x8(%rsp), %rax
movb $0x6e, (%rax)
jmp 0x455ac1
movq %r14, %rbx
movl 0x4(%r12), %eax
testl $0x2800, %eax           # imm = 0x2800
je 0x454d21
movq 0x8(%rsp), %rcx
orb $0x8, 0x6(%rcx)
btl $0xb, %eax
movq 0x28(%rsp), %r14
jb 0x454d46
movl 0x28(%r14), %esi
leaq 0xfd932(%rip), %rdx     # 0x552669
movq 0x18(%rsp), %rdi
movl $0x22, %ecx
callq 0x455f40
movb $0x1, %al
movq 0x18(%rsp), %rcx
cmpb $0x2, 0x10c(%rcx)
jae 0x454da5
movb $0x1, %cl
movq 0x38(%rsp), %rbp
cmpq $0x0, 0x28(%r12)
je 0x45569d
testb %bpl, %bpl
je 0x455900
movzwl 0x28(%r14), %esi
movl 0x4(%r12), %edx
testb $0x1, %sil
je 0x4558d5
btl $0x10, %edx
movq 0x8(%rsp), %rdi
movq 0x48(%rdi), %r8
jb 0x4558be
testq %r8, %r8
setne %dil
jmp 0x4558c6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x451e70
testq %rbp, %rbp
movq 0x8(%rsp), %r13
jne 0x455971
jmp 0x455ac1
movq %rax, (%rcx)
movq (%r13), %rsi
movq 0x8(%rsp), %rax
leaq 0x2c(%rax), %rcx
movq %rcx, 0x68(%rsp)
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
leaq 0x40(%rax), %rcx
movq %rcx, 0x90(%rsp)
movq $0x0, 0x40(%rax)
testq %rbp, %rbp
movq %rsi, 0x88(%rsp)
je 0x454e14
movq 0x28(%rsp), %rdx
testb $0x6, 0x28(%rdx)
je 0x4555bc
xorl %r15d, %r15d
jmp 0x454e1c
xorl %r15d, %r15d
movq 0x28(%rsp), %rdx
movq %r12, %r8
xorl %ebp, %ebp
testq %rbp, %rbp
sete %al
testq %r8, %r8
setne %cl
andb %al, %cl
movb %cl, 0x37(%rsp)
leaq 0xa8(%r13), %rax
movq %rax, 0x70(%rsp)
movq $0x0, 0x40(%rsp)
movb $-0x62, 0x7(%rsp)
movl $0xffffffff, 0x30(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x80(%rsp)
xorl %r14d, %r14d
movq %rdx, 0x28(%rsp)
movq %r8, 0x58(%rsp)
movq %rbp, 0x38(%rsp)
movq %r13, 0x18(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x8(%rdx), %rbx
testq %rbx, %rbx
je 0x45510b
movl (%rbx), %eax
movl %eax, 0xa4(%rsp)
testl %eax, %eax
jle 0x45510f
addq $0x8, %rbx
xorl %edx, %edx
movl $0x0, 0x14(%rsp)
movl %r14d, %r13d
movq %r15, 0x60(%rsp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x454f5f
testb $0x8, 0xd(%rax)
je 0x454f5f
movq %rsi, 0x78(%rsp)
movq (%rax), %r12
movslq (%r12), %r15
xorl %ebp, %ebp
testq %r15, %r15
jle 0x454f39
movl %edx, 0x54(%rsp)
addq $0x18, %r12
xorl %r14d, %r14d
movq (%r12), %rdi
movq 0x20(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x4561d3
testl %eax, %eax
je 0x454f23
incl 0x14(%rsp)
movq 0x8(%rsp), %rax
movw %r14w, 0x30(%rax)
movl $0x2, %r13d
movl $0x1, %ebp
movq %rbx, 0x40(%rsp)
incq %r14
addq $0x20, %r12
cmpq %r14, %r15
jne 0x454ee9
testl %ebp, %ebp
setne %bpl
movl 0x54(%rsp), %edx
movq 0x58(%rsp), %r8
testq %r8, %r8
sete %al
orb %bpl, %al
movl %r13d, %r14d
movq 0x60(%rsp), %r15
movq 0x38(%rsp), %rbp
movq 0x78(%rsp), %rsi
jne 0x4550f3
testq %rbp, %rbp
je 0x454f72
cmpq %r15, 0x70(%rsi)
je 0x454f72
movl %r13d, %r14d
jmp 0x4550f3
testq %r8, %r8
movq %rsi, 0x78(%rsp)
je 0x455010
movq %r15, %r12
movl %edx, %r15d
movq 0x18(%rbx), %r14
movq %r14, %rdi
testq %r14, %r14
jne 0x454f9a
movq 0x78(%rsp), %rax
movq (%rax), %rdi
movq %r8, %rbp
movq %r8, %rsi
callq 0x4079b2
testl %eax, %eax
je 0x454fbf
movl %r13d, %r14d
movl %r15d, %edx
movq %r12, %r15
movq %rbp, %r8
movq 0x38(%rsp), %rbp
jmp 0x4550f3
testq %r14, %r14
movl %r15d, %edx
movq %r12, %r15
movq %rbp, %r8
movq 0x38(%rsp), %rbp
movq 0x78(%rsp), %rsi
je 0x455010
movq 0x18(%rsp), %rax
cmpb $0x2, 0x10c(%rax)
jb 0x455010
movq 0x18(%rsp), %rax
movq 0x190(%rax), %rax
testq %rax, %rax
je 0x455010
movq 0x90(%rsp), %rcx
cmpq %rcx, (%rax)
je 0x455009
movq 0x18(%rax), %rax
jmp 0x454ff1
movq $0x0, (%rax)
leal 0x1(%r13), %r14d
testl %r13d, %r13d
movq 0x40(%rsp), %rax
cmoveq %rbx, %rax
movq %rax, 0x40(%rsp)
movswl 0x46(%rsi), %eax
movl %eax, 0x98(%rsp)
testl %eax, %eax
jle 0x4550f3
movl %edx, 0x54(%rsp)
movl %r14d, 0x84(%rsp)
movq 0x8(%rsi), %r12
xorl %ebp, %ebp
movq (%r12), %rdi
movq 0x20(%rsp), %rsi
callq 0x4079b2
testl %eax, %eax
jne 0x4550a2
cmpl $0x1, 0x14(%rsp)
jne 0x4550b3
testb $0x4, 0x3c(%rbx)
jne 0x4550a2
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x4550b3
movslq 0x8(%rax), %r14
testq %r14, %r14
jle 0x4550b3
movq (%rax), %r15
shlq $0x4, %r14
xorl %r13d, %r13d
movq (%r15,%r13), %rdi
movq 0x20(%rsp), %rsi
callq 0x4079b2
testl %eax, %eax
je 0x4550a2
addq $0x10, %r13
cmpq %r13, %r14
jne 0x455085
jmp 0x4550b3
incl %ebp
addq $0x20, %r12
cmpl 0x98(%rsp), %ebp
jne 0x45504a
jmp 0x4550d8
incl 0x14(%rsp)
movq 0x78(%rsp), %rax
movswl 0x44(%rax), %eax
cmpl %eax, %ebp
movl $0xffff, %eax           # imm = 0xFFFF
cmovel %eax, %ebp
movq 0x8(%rsp), %rax
movw %bp, 0x30(%rax)
movq %rbx, 0x40(%rsp)
movq 0x60(%rsp), %r15
movq 0x58(%rsp), %r8
movq 0x38(%rsp), %rbp
movl 0x84(%rsp), %r14d
movl 0x54(%rsp), %edx
incl %edx
addq $0x70, %rbx
movl %r14d, %r13d
cmpl 0xa4(%rsp), %edx
jne 0x454eb0
jmp 0x455117
xorl %ebx, %ebx
jmp 0x45516e
movl $0x0, 0x14(%rsp)
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x45515c
movl 0x40(%rcx), %edx
movq 0x68(%rsp), %rax
movl %edx, 0x30(%rsp)
movl %edx, (%rax)
movq 0x20(%rcx), %rax
movq 0x90(%rsp), %rdx
movq %rax, (%rdx)
testb $0x8, 0x3c(%rcx)
movq 0x18(%rsp), %r13
movl 0x14(%rsp), %ebx
je 0x455156
movq 0x8(%rsp), %rcx
orb $0x10, 0x6(%rcx)
movq 0x70(%rax), %r15
jmp 0x45516e
movq $0x0, 0x40(%rsp)
movq 0x18(%rsp), %r13
movl 0x14(%rsp), %ebx
testl %r14d, %r14d
sete %al
testb %al, 0x37(%rsp)
je 0x4551b9
movl %ebx, 0x14(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rbp
testq %rbp, %rbp
je 0x4551b5
movb 0xc0(%r13), %bl
cmpb $0x75, %bl
je 0x4551c8
leaq 0xfd5ef(%rip), %rdi     # 0x55278d
movq %r8, %r14
movq %r8, %rsi
callq 0x4079b2
testl %eax, %eax
je 0x4551ec
cmpb $0x74, %bl
movq %r14, %r8
jne 0x4551c8
xorl %ebp, %ebp
jmp 0x4551ff
movq 0x48(%rsp), %rax
movzwl 0x28(%rax), %r12d
jmp 0x4553ae
leaq 0xfd5c2(%rip), %rdi     # 0x552791
movq %r8, %rbx
movq %r8, %rsi
callq 0x4079b2
xorl %ecx, %ecx
testl %eax, %eax
je 0x4551e7
xorl %ebp, %ebp
movq %rbx, %r8
jmp 0x4551ff
movq %rbx, %r8
jmp 0x4551f4
movl $0x1, %ecx
movq %r14, %r8
movq 0x68(%rsp), %rax
movl %ecx, (%rax)
movl %ecx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movl 0x28(%rax), %r12d
btl $0x9, %r12d
jae 0x45524c
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x45524c
leaq 0xfd576(%rip), %rdi     # 0x552795
movq %r8, %rsi
movq %r8, %r14
callq 0x4079b2
movq %r14, %r8
testl %eax, %eax
jne 0x45524c
movq 0x28(%rbx), %rax
movq 0x28(%rax), %rbp
movq 0x68(%rsp), %rax
movl $0x2, (%rax)
movl $0x2, 0x30(%rsp)
testq %rbp, %rbp
je 0x455297
movq 0x70(%rbp), %r15
movswl 0x46(%rbp), %r13d
testl %r13d, %r13d
jle 0x4552a8
movl %r12d, %r14d
movq %r15, %r12
movq 0x8(%rbp), %r15
xorl %ebx, %ebx
movq (%r15), %rdi
movq 0x20(%rsp), %rsi
callq 0x4079b2
testl %eax, %eax
je 0x4552ac
incl %ebx
addq $0x20, %r15
cmpl %ebx, %r13d
jne 0x45526b
movl %r13d, %ebx
movq %r12, %r15
movq 0x58(%rsp), %r8
movl %r14d, %r12d
jmp 0x4552ca
xorl %r14d, %r14d
movq 0x38(%rsp), %rbp
movl 0x14(%rsp), %ebx
jmp 0x455484
xorl %ebx, %ebx
jmp 0x4552c5
movswl 0x44(%rbp), %eax
cmpl %ebx, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovel %eax, %ebx
movq %r12, %r15
movq 0x58(%rsp), %r8
movl %r14d, %r12d
cmpl %r13d, %ebx
jl 0x4552ee
movq %r8, %r14
movq 0x20(%rsp), %rdi
callq 0x414fca
testl %eax, %eax
je 0x4552eb
movb 0x40(%rbp), %al
andb $0x40, %al
cmpb $0x1, %al
movl $0x0, %eax
sbbl %eax, %eax
orl %eax, %ebx
movq %r14, %r8
movl $0x1, %r14d
cmpl %r13d, %ebx
jge 0x45532f
incl 0x14(%rsp)
cmpl $0x2, 0x30(%rsp)
movq 0x18(%rsp), %r13
jne 0x455336
cmpb $0x2, 0x10c(%r13)
jb 0x45535e
movq 0x8(%rsp), %rax
movw %bx, 0x30(%rax)
movq %rbp, 0x40(%rax)
movb $-0x62, 0x7(%rsp)
movl $0x2, 0x30(%rsp)
jmp 0x4553a5
movq 0x18(%rsp), %r13
jmp 0x4553a5
testl %ebx, %ebx
js 0x455381
movl $0x1, %eax
movl %ebx, %ecx
shll %cl, %eax
cmpl $0x20, %ebx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovael %ecx, %eax
cmpl $0x0, 0x30(%rsp)
je 0x45538c
orl %eax, 0xbc(%r13)
jmp 0x455393
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
addl 0x30(%rax), %ebx
movq 0x8(%rsp), %rax
movl %ebx, 0x2c(%rax)
orb $0x40, 0x6(%rax)
movb $-0x5c, 0x7(%rsp)
movl %ebx, 0x30(%rsp)
jmp 0x4553a5
movq 0x8(%rsp), %rax
movb $0x44, 0x1(%rax)
jmp 0x455398
orl %eax, 0xb8(%r13)
movq 0x8(%rsp), %rax
movq %rbp, 0x40(%rax)
movw %bx, 0x30(%rax)
movb $0x4d, 0x7(%rsp)
movq 0x38(%rsp), %rbp
movl 0x14(%rsp), %ebx
testl %ebx, %ebx
jne 0x45540a
cmpl $0x1, %r14d
jne 0x45540a
cmpq $0x0, 0x40(%rsp)
je 0x45540a
movl $0x1, %r14d
testb $0x20, %r12b
jne 0x45540a
movl %r12d, %r13d
movq %r8, %r12
movq 0x20(%rsp), %rdi
callq 0x414fca
testl %eax, %eax
je 0x4553ff
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
testb $0x40, 0x40(%rax)
movq %r12, %r8
movl %r13d, %r12d
movq 0x18(%rsp), %r13
jne 0x45540a
jmp 0x4558aa
movq %r12, %r8
movl %r13d, %r12d
movq 0x18(%rsp), %r13
testq %r8, %r8
jne 0x455484
testl %ebx, %ebx
jne 0x455484
movl %r12d, %eax
andl $0x80, %eax
je 0x455484
movl %r12d, 0x14(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rax), %r12
testq %r12, %r12
jle 0x45548a
movq %r15, 0x60(%rsp)
movq %r13, %rbp
movq %rax, 0x98(%rsp)
leaq 0x10(%rax), %r13
xorl %r15d, %r15d
movq (%r13), %rbx
testq %rbx, %rbx
je 0x455464
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x4079b2
testl %eax, %eax
je 0x4554c6
incq %r15
addq $0x20, %r13
cmpq %r15, %r12
jne 0x45544a
movq %rbp, %r13
movq 0x60(%rsp), %r15
movq 0x58(%rsp), %r8
movq 0x38(%rsp), %rbp
jmp 0x45548f
testl %ebx, %ebx
je 0x45548f
jmp 0x455506
movq 0x58(%rsp), %r8
movq 0x48(%rsp), %rdx
movq 0x18(%rdx), %rdx
incl 0x80(%rsp)
testq %rdx, %rdx
jne 0x454e77
leaq 0xfd30e(%rip), %rbx     # 0x5527bd
testq %r8, %r8
je 0x455655
movq $0x0, 0x48(%rsp)
jmp 0x455605
movq -0x8(%r13), %rax
testb $0x1, 0x14(%rsp)
jne 0x4554db
testb $0x2, 0x4(%rax)
jne 0x455594
movb (%rax), %cl
cmpb $-0x5c, %cl
movq %rbp, %r13
jne 0x4554e8
movb 0x36(%rax), %cl
cmpb $0x7f, %cl
movq 0x98(%rsp), %rsi
je 0x45551b
movzbl %cl, %ecx
cmpl $0xa5, %ecx
jne 0x455527
addq $0x20, %rax
jmp 0x45551f
cmpl $0x1, %ebx
jne 0x4555fe
movb $0x1, %bl
movb 0x7(%rsp), %bpl
jmp 0x455705
movq 0x20(%rax), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x455581
leaq 0x11ce1f(%rip), %r8     # 0x57234d
movq %r13, %rdi
movl %r15d, %edx
movq 0x8(%rsp), %rcx
movl 0x80(%rsp), %r9d
callq 0x4562fa
cmpb $0x2, 0x10c(%r13)
jb 0x4555b2
movq 0x190(%r13), %rax
testq %rax, %rax
movq 0x60(%rsp), %r15
je 0x455797
movq 0x8(%rsp), %rcx
cmpq %rcx, (%rax)
je 0x45568c
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x45556a
jmp 0x455797
leaq 0xfcd5d(%rip), %rsi     # 0x5522e5
movq %r13, %rdi
xorl %eax, %eax
callq 0x40e48a
jmp 0x4555a8
leaq 0xfd203(%rip), %rsi     # 0x55279e
movq %rbp, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x40e48a
movl $0x2, %eax
jmp 0x454bbb
movq 0x60(%rsp), %r15
jmp 0x455797
movslq 0x28(%rsi), %rbx
testq %rbx, %rbx
jle 0x455698
movq 0x20(%rsi), %r14
shlq $0x5, %rbx
xorl %r15d, %r15d
movq (%r14,%r15), %rdi
movq %rbp, %rsi
callq 0x4079b2
testl %eax, %eax
je 0x4556b9
addq $0x20, %r15
cmpq %r15, %rbx
jne 0x4555d4
movq 0x28(%rsp), %rdx
xorl %r15d, %r15d
jmp 0x4556c3
leaq 0xfd1c7(%rip), %rbx     # 0x5527cc
testq %rbp, %rbp
je 0x45562b
leaq 0xfd1d1(%rip), %rsi     # 0x5527e2
movq %r13, %rdi
movq %rbx, %rdx
movq %rbp, %rcx
movq 0x20(%rsp), %r9
xorl %eax, %eax
callq 0x40e48a
jmp 0x4556f1
testq %r8, %r8
je 0x4556d8
leaq 0xfc523(%rip), %rsi     # 0x551b5e
movq %r13, %rdi
movq %rbx, %rdx
movq %r8, %rcx
movq 0x20(%rsp), %r8
xorl %eax, %eax
callq 0x40e48a
jmp 0x4556f1
movq 0x8(%rsp), %rdi
testb $0x40, 0x4(%rdi)
jne 0x45589a
movq %r8, %r14
callq 0x43fd7a
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x454bbb
movq $0x0, 0x48(%rsp)
movq %r14, %r8
jmp 0x455605
movq $0x0, (%rax)
jmp 0x455797
xorl %r15d, %r15d
jmp 0x4556be
movq 0x8(%rsp), %rdx
cmpq $0x0, 0x48(%rdx)
je 0x454d69
leaq 0xfcfd1(%rip), %rsi     # 0x552685
jmp 0x455920
movq 0x18(%r14,%r15), %r15
movq 0x28(%rsp), %rdx
movq %r12, %r8
jmp 0x454e21
xorl %r12d, %r12d
movq 0x28(%rsp), %r14
jmp 0x455904
leaq 0xff28f(%rip), %rsi     # 0x55496e
movq %r13, %rdi
movq %rbx, %rdx
movq 0x20(%rsp), %rcx
xorl %eax, %eax
callq 0x40e48a
movb 0x7(%rsp), %bpl
movb $0x1, 0x1d(%r13)
movq 0x28(%rsp), %rax
incl 0x24(%rax)
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
movzwl 0x30(%rax), %eax
testw %ax, %ax
js 0x455738
cmpq $0x0, 0x40(%rsp)
je 0x455738
cmpw $0x3f, %ax
movl $0x3f, %ecx
cmovbl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq 0x40(%rsp), %rcx
orq %rax, 0x58(%rcx)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x455753
movq 0x88(%rsp), %rdi
callq 0x4381eb
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rax), %rsi
testq %rsi, %rsi
je 0x455776
movq 0x88(%rsp), %rdi
callq 0x4381eb
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movb %bpl, (%rax)
orb $-0x80, 0x6(%rax)
movl $0x2, %eax
testb %bl, %bl
je 0x454bbb
movq 0x8(%rsp), %rax
testb $0x40, 0x6(%rax)
movq 0x28(%rsp), %rbx
jne 0x455873
testq %r15, %r15
je 0x455873
movq (%r13), %rcx
cmpq $0x0, 0x198(%rcx)
je 0x455873
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rcx), %rdx
addq $0x18, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
leaq 0x20(%rdx), %rsi
cmpq %r15, (%rdx)
movq %rsi, %rdx
jne 0x4557dc
movq 0x8(%rsp), %rdx
cmpb $0x4d, (%rdx)
jne 0x455843
movq 0x70(%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x455873
movq 0x8(%rsp), %rdx
movswq 0x30(%rdx), %rdx
testw %dx, %dx
jns 0x45581e
movswq 0x44(%rax), %rdx
testq %rdx, %rdx
js 0x455aee
shlq $0x5, %rdx
addq 0x8(%rax), %rdx
movq (%rdx), %rdx
movq (%rax), %rsi
movq %r13, %rdi
callq 0x45643f
cmpl $0x2, %eax
jne 0x455873
movq 0x8(%rsp), %rax
movb $0x6e, (%rax)
jmp 0x455873
movslq (%rax), %rdx
testq %rdx, %rdx
jle 0x455873
movq 0x68(%rsp), %rsi
movl (%rsi), %esi
addq $0x28, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
cmpl 0x20(%rax), %esi
je 0x4557f4
addq $0x70, %rax
movq %rax, 0x70(%rsp)
decq %rdx
jne 0x45585b
incl 0x20(%rbx)
movl $0x1, %eax
movq 0x48(%rsp), %rcx
cmpq %rbx, %rcx
je 0x454bbb
movq 0x18(%rbx), %rbx
incl 0x20(%rbx)
cmpq %rcx, %rbx
jne 0x455889
jmp 0x454bbb
movb $0x6a, (%rdi)
movq $0x0, 0x40(%rdi)
jmp 0x455ac1
movq 0x8(%rsp), %rax
movw $0xffff, 0x30(%rax)     # imm = 0xFFFF
movb $0x44, 0x1(%rax)
jmp 0x45550f
movb $0x1, %dil
testq %r8, %r8
je 0x4558d5
shrl $0xe, %esi
andl $0x1, %esi
xorb $0x1, %dil
orb %sil, %dil
jne 0x455900
btl $0x10, %edx
jb 0x455a90
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
leaq 0xfcdc8(%rip), %rax     # 0x5526b8
leaq 0xfcdba(%rip), %rdx     # 0x5526b1
cmoveq %rax, %rdx
jmp 0x455a97
testb %cl, %cl
jne 0x455915
movq 0x18(%rsp), %rdi
movq (%rdi), %rcx
cmpb $0x0, 0xb5(%rcx)
je 0x455927
testb %al, %al
jne 0x455941
leaq 0xfcdd6(%rip), %rsi     # 0x5526f6
movq 0x18(%rsp), %rdi
jmp 0x45592e
leaq 0xfcdb1(%rip), %rsi     # 0x5526df
movq 0x20(%rsp), %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x40e48a
incl 0x24(%r14)
testb %bpl, %bpl
je 0x455ab6
movq 0x8(%rsp), %r13
cmpq $0x0, 0x48(%r13)
movl $0xfffe, %eax           # imm = 0xFFFE
movl $0xbfff, %ecx           # imm = 0xBFFF
cmovel %eax, %ecx
andw %cx, 0x28(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x451e70
movq 0x48(%r13), %rax
testq %rax, %rax
je 0x4559f1
movq 0x30(%r14), %rbx
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0x451e70
movq 0x48(%r13), %rax
movq 0x10(%rax), %rsi
movq %r15, %rdi
callq 0x451e70
movq 0x48(%r13), %rdx
movq 0x38(%rdx), %rsi
testq %rsi, %rsi
je 0x4559b3
movq %r15, %rdi
callq 0x451c38
movq 0x48(%r13), %rdx
movq 0x78(%rbx), %rsi
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r12, %rcx
callq 0x455ff3
movq 0x70(%rbx), %rsi
testq %rsi, %rsi
je 0x455a77
movq 0x48(%r13), %rdx
movq %r14, %rdi
callq 0x452272
testl %eax, %eax
jne 0x455a85
movq 0x70(%rbx), %rax
jmp 0x455a79
movb $-0x61, (%r13)
movb $0x0, 0x36(%r13)
leaq 0xb29(%rip), %r15       # 0x45652b
movq %r13, %rcx
xorl %r13d, %r13d
leaq 0xa8(%rsp), %rbp
leaq 0xb8(%rsp), %rbx
movq 0x8(%r14), %rax
movq 0x20(%rcx), %rsi
movq %r15, 0xc0(%rsp)
movq %r13, 0xc8(%rsp)
movq %rbp, 0xe0(%rsp)
movq %rax, 0xa8(%rsp)
movq %r13, 0xb0(%rsp)
movq %rbx, %rdi
callq 0x451e70
cmpl $0x0, 0xb0(%rsp)
jg 0x455acb
cmpl $0x0, 0xb4(%rsp)
je 0x455acb
movq 0x8(%rsp), %rcx
incb 0x36(%rcx)
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x455a18
jmp 0x455ae3
xorl %eax, %eax
movq 0x48(%r13), %rcx
movq %rax, 0x30(%rcx)
movq %rcx, 0x70(%rbx)
movq 0x28(%rsp), %rax
orb $0x40, 0x29(%rax)
jmp 0x455ac1
leaq 0xfcc1a(%rip), %rdx     # 0x5526b1
movq 0x20(%rsp), %rcx
leaq 0xfcc1f(%rip), %rsi     # 0x5526c2
movq 0x18(%rsp), %rdi
movq %r13, %r8
xorl %eax, %eax
callq 0x40e48a
incl 0x24(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x451e70
movl $0x1, %eax
jmp 0x454bbb
movzwl 0x4(%r12), %eax
andl $0x1000, %eax           # imm = 0x1000
orw 0x28(%r14), %ax
orl $0x10, %eax
movw %ax, 0x28(%r14)
movq 0x28(%rsp), %rax
orb $0x1, 0x28(%rax)
jmp 0x455ac1
leaq 0xfccfa(%rip), %rdx     # 0x5527ef
jmp 0x455829