@Override
  public DfaInstructionState[] accept(@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) {
    DfaValue dfaRight = stateBefore.pop();
    DfaValue dfaLeft = stateBefore.pop();

    if ((myRelation == RelationType.EQ || myRelation == RelationType.NE) &&
        !myForceEqualityByContent && shouldCompareByEquals(stateBefore, dfaLeft, dfaRight)) {
      ArrayList<DfaInstructionState> states = new ArrayList<>(2);
      DfaMemoryState equality = stateBefore.createCopy();
      DfaCondition condition = dfaLeft.eq(dfaRight);
      if (equality.applyCondition(condition)) {
        pushResult(interpreter, equality, BOOLEAN);
        states.add(nextState(interpreter, equality));
      }
      if (stateBefore.applyCondition(condition.negate())) {
        pushResult(interpreter, stateBefore, booleanValue(myRelation == RelationType.NE));
        states.add(nextState(interpreter, stateBefore));
      }
      return states.toArray(DfaInstructionState.EMPTY_ARRAY);
    }
    RelationType[] relations = splitRelation(myRelation);

    ArrayList<DfaInstructionState> states = new ArrayList<>(relations.length);

    for (int i = 0; i < relations.length; i++) {
      RelationType relation = relations[i];
      boolean result = myRelation.isSubRelation(relation);
      DfaCondition condition = dfaLeft.cond(relation, dfaRight).correctForRelationResult(result);
      if (condition == DfaCondition.getFalse()) continue;
      if (condition == DfaCondition.getTrue()) {
        pushResult(interpreter, stateBefore, booleanValue(result));
        return nextStates(interpreter, stateBefore);
      }
      final DfaMemoryState copy = i == relations.length - 1 && !states.isEmpty() ? stateBefore : stateBefore.createCopy();
      if (copy.applyCondition(condition) &&
          copy.meetDfType(dfaLeft, copy.getDfType(dfaLeft).correctForRelationResult(myRelation, result)) &&
          copy.meetDfType(dfaRight, copy.getDfType(dfaRight).correctForRelationResult(myRelation, result))) {
        pushResult(interpreter, copy, booleanValue(result));
        states.add(nextState(interpreter, copy));
      }
    }
    if (states.isEmpty()) {
      // Neither of relations could be applied: likely comparison with NaN; do not split the state in this case, just push false
      pushResult(interpreter, stateBefore, FALSE);
      return nextStates(interpreter, stateBefore);
    }

    return states.toArray(DfaInstructionState.EMPTY_ARRAY);
  }
@Override
  public DfaInstructionState[] accept(@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore)