@Override
  public DfaInstructionState[] accept(@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore) {
    DfaValueFactory factory = interpreter.getFactory();
    DfaCallArguments callArguments = this.popCall(interpreter, stateBefore);

    Set<DfaMemoryState> finalStates = new LinkedHashSet<>();

    PsiType qualifierType = DfaPsiUtil.dfTypeToPsiType(factory.getProject(), stateBefore.getDfType(callArguments.getQualifier()));
    PsiMethod realMethod = findSpecificMethod(qualifierType);
    DfaValue defaultResult = getMethodResultValue(callArguments, stateBefore, factory, realMethod);
    DfaCallState initialState = new DfaCallState(stateBefore, callArguments, defaultResult);
    Set<DfaCallState> currentStates = Collections.singleton(initialState);
    if (callArguments.getArguments() != null && !(defaultResult.getDfType() instanceof DfConstantType)) {
      for (MethodContract contract : getContracts()) {
        currentStates = addContractResults(contract, currentStates, factory, finalStates);
        if (currentStates.size() + finalStates.size() > interpreter.getComplexityLimit()) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Too complex contract on " + getContext() + ", skipping contract processing");
          }
          finalStates.clear();
          currentStates = Collections.singleton(initialState);
          break;
        }
      }
    }
    for (DfaCallState callState : currentStates) {
      callState.getMemoryState().push(defaultResult);
      finalStates.add(callState.getMemoryState());
    }

    DfaInstructionState[] result = new DfaInstructionState[finalStates.size()];
    int i = 0;
    DfaValue[] args = callArguments.toArray();
    for (DfaMemoryState state : finalStates) {
      ContractValue.flushContractTempVariables(state);
      boolean keepNonFlushed = state.peek() instanceof DfaVariableValue;
      DfaValue tos = null;
      if (keepNonFlushed) {
        tos = state.pop();
      }
      callArguments.flush(state, factory, realMethod);
      if (!keepNonFlushed) {
        tos = state.pop();
      }
      pushResult(interpreter, state, tos, args);
      result[i++] = nextState(interpreter, state);
    }
    return result;
  }
@Override
  public DfaInstructionState[] accept(@NotNull DataFlowInterpreter interpreter, @NotNull DfaMemoryState stateBefore)