anchor.diff:                      false ->
                           case ErrorNext of
                               none ->
  -                                ?f_debug("Picked: ~w\n",[H]),
  -                                [H];
  +                                case ordsets:is_element(Lid, Candidates) of
  +                                    true -> [Lid];
  +                                    false -> ?f_debug("Picked: ~w\n",[H]), [H]
  +                                end;
                               Else ->
                                   ?f_debug("Picked to crash: ~w\n",[H]),
                                   [Else]
  
positive.code:     ?f_debug("A:~p B:~p\n",[_TransitionA, _TransitionB]),
      false.
  
  add_all_backtracks(Transition, #dpor_state{trace = Trace} = State) ->
      case State#dpor_state.fake_dpor of
          false ->
              NewTrace = add_all_backtracks_trace(Transition, Trace),
              State#dpor_state{trace = NewTrace};
          true ->
              %% add_some_next will take care of all the backtracks.
              State
      end.
  
  add_all_backtracks_trace(exited, Trace) ->
      Trace;
  add_all_backtracks_trace({Lid, _} = Transition, Trace) ->
      [#trace_state{clock_map = ClockMap}|_] = Trace,
      ClockVector = lookup_clock(Lid, ClockMap),
      add_all_backtracks_trace(Transition, ClockVector, Trace, []).
  
  add_all_backtracks_trace(_Transition, _ClockVector, [_] = Init, Acc) ->
      lists:reverse(Acc, Init);
  add_all_backtracks_trace(Transition, ClockVector, [StateI|Trace], Acc) ->
      #trace_state{i = I, last = {ProcSI, _} = SI} = StateI,
      Dependent = dependent(Transition, SI),
      Clock = lookup_clock_value(ProcSI, ClockVector),
      ?f_debug("Dep ~p andalso ~p\n",[Dependent, I > Clock]),
      case Dependent andalso I > Clock of
          false ->
              add_all_backtracks_trace(Transition, ClockVector, Trace, [StateI|Acc]);
          true ->
              ?f_debug("~p: I:~p ~p\n",[Transition, I, SI]),
              [#trace_state{enabled = Enabled, backtrack = Backtrack, sleep_set = SleepSet} =
                   PreSI|Rest] = Trace,
              P = pick_from_E(ordsets:subtract(Enabled, SleepSet), I, ClockVector),
              NewBacktrack = ordsets:add_element(P, Backtrack),
              NewSleepSet = ordsets:add_element(ProcSI, SleepSet),
              ?f_debug("      New backtrack: ~w\n", [NewBacktrack]),
              NewPreSI =
                  PreSI#trace_state{backtrack = NewBacktrack, sleep_set = NewSleepSet},
              lists:reverse(Acc, [StateI,NewPreSI|Rest])
      end.
  
  lookup_clock(P, ClockMap) ->
  
negative.code:             {error, _} -> Lid;
              _Else -> none
          end,
      NewPreemptions =
          case ordsets:is_element(LLid, Enabled) of
              true ->
                  case Lid =:= LLid of
                      false -> Preemptions + 1;
                      true -> Preemptions
                  end;
              false -> Preemptions
          end,
      CommonNewTraceTop =
          #trace_state{i = NewN, last = Selected, nexts = NewNexts,
                       enabled = NewEnabled, blocked = NewBlocked,
                       clock_map = NewClockMap, sleep_set = NewSleepSet,
                       pollable = NewPollable, error_nxt = ErrorNext,
                       preemptions = NewPreemptions},
      NewTraceTop = handle_instruction(Selected, CommonNewTraceTop),
      UpdatedClockVector = lookup_clock(Lid, NewTraceTop#trace_state.clock_map),
      replace_messages(Lid, UpdatedClockVector),
  