anchor.diff:                           blocked = NewBlocked,
                            nexts = NewNexts,
                            lid_trace = NewLidTrace};
  -handle_instruction_al({Lid, {'receive', [HasMatching, HasAfter]}} = Transition,
  -                      TraceTop, ReceiveDetails) ->
  +handle_instruction_al({Lid, {'receive', _}} = Transition, TraceTop,
  +                      ReceiveDetails) ->
       #trace_state{lid_trace = LidTrace} = TraceTop,
       {{value, Transition}, TmpLidTrace} = queue:out_r(LidTrace),
       NewLast =
  
positive.code:     false -> find_one_from_E(P, ClockVector, Enabled, Rest)
    end.
  
  %% - add new entry with new entry
  %% - wait any possible additional messages
  %% - check for async
  update_trace({Lid, _} = Selected, Next, State) ->
      ?f_debug("Sele: ~w Next: ~w\n",[Selected, Next]),
      #dpor_state{trace = [TraceTop|_] = Trace} = State,
      #trace_state{i = I, enabled = Enabled, blocked = Blocked,
                   nexts = Nexts, lid_trace = LidTrace,
                   clock_map = ClockMap} = TraceTop,
      NewN = I+1,
      ClockVector = lookup_clock(Lid, ClockMap),
      LidsClockVector = dict:store(Lid, NewN, ClockVector),
      NewClockMap = dict:store(Lid, LidsClockVector, ClockMap),
      NewNexts = dict:store(Lid, Next, Nexts),
      {NewEnabled, NewBlocked} =
          update_lid_enabled(Lid, Next, Enabled, Blocked),
      NewLidTrace = queue:in(Selected, LidTrace),
      CommonNewTraceTop =
          #trace_state{i = NewN, last = Selected, nexts = NewNexts,
                       enabled = NewEnabled, blocked = NewBlocked,
                       lid_trace = NewLidTrace, clock_map = NewClockMap},
      NewTraceTop = handle_instruction(Selected, CommonNewTraceTop),
      UnblockedTraceTop = check_blocked(NewTraceTop),
      State#dpor_state{trace = [UnblockedTraceTop|Trace]}.
  
  update_lid_enabled(Lid, Next, Enabled, Blocked) ->
      case is_next_enabled(Next) of
  
negative.code:                     Next = wait_next(Lid, Cmd),
                      ?f_debug("Next: ~p\n",[Next]),
                      LocalAddState = add_local_backtracks(Selected, State),
                      %% ?f_debug("AAS: ~p\n",[AllAddState]),
                      UpdState = update_trace(Selected, Next, LocalAddState),
                      %% ?f_debug("LAS: ~p\n",[UpdState]),
                      AllAddState = add_all_backtracks({Lid, Next}, UpdState),
                      NewChildState = add_all_child_backtracks(Cmd, AllAddState),
                      %% ?f_debug("US : ~p\n",[UpdState]),
                      NewState = add_some_next_to_backtrack(NewChildState),
                      explore(NewState)
  