anchor.diff:        add_old_backtracks_for_p(Next, Rest, [StateI|Acc], ClockMap)
     end.
   
  -add_one_from_E(P, PStates, Backtrack) ->
  +add_from_E(P, PStates, ForwardTrace, ClockMap, Backtrack) ->
     %% This is an overapproximation, as instead of the E set described in the
     %% algorithm we look only whether the process in question is enabled.
  -  Enabled =
  -    case dict:find(P, PStates) of
  -      {ok, PState} ->
  -        case is_p_enabled(PState) of
  -          {true, _C} -> true;
  -          false -> false
  -        end;
  -      error -> false
  -    end,
  -  case Enabled of
  +  Enabled = all_enabled(PStates),
  +  case lists:member(P, Enabled) of
       true ->
         ?debug("        Enabled.\n"),
         ordsets:add_element(P, Backtrack);
       false ->
         ?debug("        Not Enabled.\n"),
  -      Elements = all_enabled(PStates),
  -      ?debug("        All enabled: ~p\n", [Elements]),
  -      ordsets:union(Backtrack, ordsets:from_list(Elements))
  +      ClockVector = lookup_clock(P, ClockMap),
  +      case find_one_from_E(P, ClockVector, Enabled, ForwardTrace) of
  +        {true, Q} ->
  +          ?debug("        Q needs to happen: ~p\n", [Q]),
  +          ordsets:add_element(Q, Backtrack);
  +        false ->
  +          ?debug("        Adding all enabled: ~p\n", [Enabled]),
  +          ordsets:union(Backtrack, ordsets:from_list(Enabled))
  +      end
  +  end.
  +
  +find_one_from_E(_P, _ClockVector, _Enabled, []) -> false;
  +find_one_from_E(P, ClockVector, Enabled, [Sj|Rest]) ->
  +  #state{i = J, last = _Sj = {ProcSj, _}} = Sj,
  +  ?debug("          ~p: ~p\n", [J, ProcSj]),
  +  Satisfies =
  +    case lists:member(ProcSj, Enabled) of
  +      false ->
  +        ?debug("          Was not enabled\n"),
  +        false;
  +      true -> 
  +        ClockValue = lookup_clock_value(ProcSj, ClockVector),
  +        ?debug("          Clock is: ~p\n", [ClockValue]),
  +        J =< ClockValue
  +    end,
  +  case Satisfies of
  +    true ->
  +      ?debug("            Found ~p\n", [ProcSj]),
  +      {true, ProcSj};
  +    false -> find_one_from_E(P, ClockVector, Enabled, Rest)
     end.
   
   lookup_clock(PorS, ClockMap) ->
  
positive.code:     case pick_random_enabled(Trace) of
        none ->
          %% TODO: Report Check for deadlocks
          I = get(interleavings) + 1,
          put(interleavings, I),
          io:format("~p\n", [I]),
          %% Stack = get_stack(Trace),
          %% io:format("~s\n",[lists:map(fun map/1, Stack)]),
          %% io:format("~p\n", [Stack]),
          UpdatedTrace;
        {ok, P} ->
          ?debug("Picking ~p for new step.\n", [P]),
  
negative.code: 
  add_old_backtracks([#state{pstates=PStates}|_] = Trace, ClockMap) ->
    Nexts = get_all_nexts(PStates),
    ?debug("Backtrack points: Forall processes: ~p\n", [Nexts]),
    add_old_backtracks(Nexts, Trace, ClockMap).
  
  get_all_nexts(PStates) ->
  