// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
addl $-0x14, %eax
movl %eax, %ecx
movq %rcx, -0xc8(%rbp)
subl $0x89, %eax
ja 0x476191
movq -0xc8(%rbp), %rax
leaq 0x103f06(%rip), %rcx    # 0x5797dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x47590c
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4759d7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x10a93e(%rip), %rdx    # 0x580265
movl $0x20, %ecx
callq 0x4768e0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x475953
movq $0x0, -0x40(%rbp)
jmp 0x475977
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10c(%rax), %eax
cmpl $0x2, %eax
jl 0x4759b0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x476970
movq -0x28(%rbp), %rax
movzbl 0x10c(%rax), %eax
cmpl $0x2, %eax
jl 0x4759d5
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movq -0x50(%rbp), %rdx
callq 0x476970
jmp 0x4759d7
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %r9
callq 0x4769d0
movl %eax, -0x4(%rbp)
jmp 0x4761d0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x475a1d
movq -0x58(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xcc(%rbp)
jmp 0x475a27
xorl %eax, %eax
movl %eax, -0xcc(%rbp)
jmp 0x475a27
movl -0xcc(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movl $0x0, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movb 0x5e(%rax), %al
movb %al, -0x81(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x408d10
movl %eax, -0x6c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x78(%rbp), %rsi
movl -0x5c(%rbp), %edx
xorl %r8d, %r8d
movzbl -0x81(%rbp), %ecx
callq 0x417710
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x475ad4
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x78(%rbp), %rsi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
xorl %r8d, %r8d
movzbl -0x81(%rbp), %ecx
callq 0x417710
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x475ac8
movl $0x1, -0x60(%rbp)
jmp 0x475acf
movl $0x1, -0x64(%rbp)
jmp 0x475c31
movq -0x80(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x68(%rbp)
movq -0x80(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x475b74
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x41000, %ecx          # imm = 0x41000
movl %ecx, 0x4(%rax)
cmpl $0x2, -0x5c(%rbp)
jne 0x475b50
movq -0x58(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x477610
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jge 0x475b4e
movq -0x28(%rbp), %rdi
leaq 0x10a73c(%rip), %rsi    # 0x580276
movb $0x0, %al
callq 0x4110b0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x475b72
movq -0x80(%rbp), %rax
movq 0x38(%rax), %rax
movsbl (%rax), %edx
movl $0x7800000, %ecx        # imm = 0x7800000
movl $0x800000, %eax         # imm = 0x800000
cmpl $0x75, %edx
cmovel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
jmp 0x475b74
movq -0x28(%rbp), %rdi
movq -0x80(%rbp), %rax
movq 0x38(%rax), %rcx
movl $0x1f, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x4741b0
movl %eax, -0x88(%rbp)
cmpl $0x0, -0x88(%rbp)
je 0x475be4
cmpl $0x1, -0x88(%rbp)
jne 0x475bd1
movq -0x28(%rbp), %rdi
movq -0x80(%rbp), %rax
movq 0x38(%rax), %rdx
leaq 0x10a700(%rip), %rsi    # 0x5802bd
movb $0x0, %al
callq 0x4110b0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
movb $0x6e, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4761d0
movq -0x80(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2800, %eax           # imm = 0x2800
cmpl $0x0, %eax
je 0x475c05
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x80000, %ecx          # imm = 0x80000
movl %ecx, 0x4(%rax)
movq -0x80(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x475c2f
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x10a6bb(%rip), %rdx    # 0x5802e0
movl $0x22, %ecx
callq 0x4768e0
jmp 0x475c31
movq -0x28(%rbp), %rax
movzbl 0x10c(%rax), %eax
cmpl $0x2, %eax
setge %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x475e11
cmpq $0x0, -0x80(%rbp)
je 0x475c99
movq -0x80(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x475c99
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x475c99
movq -0x28(%rbp), %rdi
movl -0x6c(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq 0x10a67c(%rip), %rsi    # 0x5802fc
movb $0x0, %al
callq 0x4110b0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x475ddf
cmpl $0x0, -0x68(%rbp)
je 0x475caf
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x475cfc
cmpl $0x0, -0x68(%rbp)
je 0x475cd1
movq -0x80(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x475cd1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x475cfc
cmpl $0x0, -0x68(%rbp)
je 0x475d6c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x475d6c
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x475d6c
movq -0x80(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
jne 0x475d18
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x475d28
leaq 0x10a609(%rip), %rax    # 0x580328
movq %rax, -0x90(%rbp)
jmp 0x475d36
leaq 0x10a600(%rip), %rax    # 0x58032f
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rdi
movq -0x90(%rbp), %rdx
movl -0x6c(%rbp), %ecx
movq -0x78(%rbp), %r8
leaq 0x10a5ea(%rip), %rsi    # 0x580339
movb $0x0, %al
callq 0x4110b0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movl $0x0, -0x68(%rbp)
jmp 0x475ddd
cmpl $0x0, -0x60(%rbp)
je 0x475dad
movq -0x28(%rbp), %rax
movq (%rax), %rax
movzbl 0xb5(%rax), %eax
cmpl $0x0, %eax
jne 0x475dad
movq -0x28(%rbp), %rdi
movl -0x6c(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq 0x10a5bf(%rip), %rsi    # 0x580356
movb $0x0, %al
callq 0x4110b0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x475ddb
cmpl $0x0, -0x64(%rbp)
je 0x475dd9
movq -0x28(%rbp), %rdi
movl -0x6c(%rbp), %edx
movq -0x78(%rbp), %rcx
leaq 0x10a5a8(%rip), %rsi    # 0x58036d
movb $0x0, %al
callq 0x4110b0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x475ddb
jmp 0x475ddd
jmp 0x475ddf
cmpl $0x0, -0x68(%rbp)
je 0x475e0f
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movl $0x1, %edx
movl $0x4000, %eax           # imm = 0x4000
cmpq $0x0, %rcx
cmovnel %eax, %edx
xorl $-0x1, %edx
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %ecx
andl %edx, %ecx
movw %cx, 0x28(%rax)
jmp 0x475e11
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x4711f0
cmpl $0x0, -0x68(%rbp)
je 0x475fd0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x475f19
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4711f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x4711f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x38(%rax), %rsi
callq 0x470f30
movq -0x28(%rbp), %rdi
movq -0x98(%rbp), %rax
movq 0x78(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x80(%rbp), %rcx
callq 0x4776b0
movq -0x98(%rbp), %rcx
xorl %eax, %eax
cmpq 0x70(%rcx), %rax
je 0x475ed8
movq -0x28(%rbp), %rdi
movq -0x98(%rbp), %rax
movq 0x70(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdx
callq 0x471a30
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x475f02
movq -0x98(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x98(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %ecx
orl $0x4000, %ecx           # imm = 0x4000
movw %cx, 0x28(%rax)
jmp 0x475fce
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movb $-0x61, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x36(%rax)
xorl %eax, %eax
cmpq $0x0, -0xa0(%rbp)
movb %al, -0xcd(%rbp)
je 0x475f67
movq -0x18(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x477960
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0xcd(%rbp)
movb -0xcd(%rbp), %al
testb $0x1, %al
jne 0x475f73
jmp 0x475f94
movq -0x18(%rbp), %rax
movb 0x36(%rax), %cl
addb $0x1, %cl
movb %cl, 0x36(%rax)
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xa0(%rbp)
jmp 0x475f33
cmpq $0x0, -0xa0(%rbp)
je 0x475fbf
movq -0x80(%rbp), %rax
movl 0x4(%rax), %edx
andl $0x1000, %edx           # imm = 0x1000
orl $0x10, %edx
movq -0xa0(%rbp), %rax
movzwl 0x28(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x28(%rax)
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x28(%rax)
jmp 0x475fd0
movl $0x1, -0x4(%rbp)
jmp 0x4761d0
jmp 0x475fde
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x476053
movq -0x20(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0xa4(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x10a38f(%rip), %rdx    # 0x58039a
movl $0x26, %ecx
callq 0x4768e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x471110
movl -0xa4(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0x476051
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movzwl 0x28(%rax), %ecx
orl $0x40, %ecx
movw %cx, 0x28(%rax)
jmp 0x476053
jmp 0x476191
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x10a33e(%rip), %rdx    # 0x5803a5
movl $0x26, %ecx
callq 0x4768e0
jmp 0x476191
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xb0(%rbp)
movzbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x4760eb
movq -0x10(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x475880
movl %eax, -0xb4(%rbp)
cmpl $0x2, -0xb4(%rbp)
jne 0x4760b8
movl $0x2, -0x4(%rbp)
jmp 0x4761d0
movq -0xb0(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x9b, %eax
jne 0x4760e9
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x36(%rax)
movq -0x18(%rbp), %rax
movb $-0x5d, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4761d0
jmp 0x4760eb
jmp 0x4760ed
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x61(%rax)
je 0x4760ff
jmp 0x476191
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x46f220
movl %eax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x30, %eax
jne 0x47615c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x46f220
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
cmpl -0xb8(%rbp), %eax
jne 0x47615a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x46f220
movl %eax, -0xbc(%rbp)
jmp 0x47616f
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x46f220
movl %eax, -0xbc(%rbp)
movl -0xb8(%rbp), %eax
cmpl -0xbc(%rbp), %eax
je 0x47618f
movq -0x28(%rbp), %rdi
leaq 0x109dd4(%rip), %rsi    # 0x57ff5c
movb $0x0, %al
callq 0x4110b0
jmp 0x476191
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x30(%rcx)
movb %al, -0xce(%rbp)
jne 0x4761ba
movq -0x28(%rbp), %rax
movq (%rax), %rax
movzbl 0x61(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xce(%rbp)
movb -0xce(%rbp), %dl
xorl %eax, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)