anchor.diff:            nexts     = dict:new()        :: dict(), %% dict(lid:lid(), {instr(), clock_vector()}),
             backtrack = ordsets:new()     :: ordsets:ordset(), %% set(lid:lid()),
             done      = ordsets:new()     :: ordsets:ordset(), %% set(lid:lid()),
  +          sleep_set = ordsets:new()     :: ordsets:ordset(), %% set(lid:lid()),
  +          sleep_map = dict:new()        :: dict(), %% dict(lid:lid(), set(lid:lid)),
             clock_map = empty_clock_map() :: clock_map(),
             lid_trace = new_lid_trace()   :: queue() %% queue(lid:lid())
            }).
  
positive.code:                     Next = wait_next(Lid, Cmd),
                      ?f_debug("Next: ~p\n",[Next]),
                      LocalAddState = add_local_backtracks(Selected, State),
                      %% ?f_debug("LAS: ~p\n",[LocalAddState]),
                      AllAddState = add_all_backtracks({Lid, Next}, LocalAddState),
                      %% ?f_debug("AAS: ~p\n",[AllAddState]),
                      UpdState = update_trace(Selected, Next, AllAddState),
                      NewChildState = add_all_child_backtracks(Cmd, UpdState),
                      %% ?f_debug("US : ~p\n",[UpdState]),
                      NewState = add_some_next_to_backtrack(NewChildState),
                      explore(NewState)
  
negative.code:         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_map = SleepMap} = PreSI|Rest] = Trace,
              {NewBacktrack, NewSleepMap} =
                  case add_from_E(Lid, Enabled, [StateI|Acc], ClockVector) of
                      {one, P} ->
                          {ordsets:add_element(P, Backtrack),
                           update_sleep_map([P], ProcSI, SleepMap)};
                      {many, Ps} ->
                          {ordsets:union(Backtrack, ordsets:from_list(Enabled)),
                           update_sleep_map(Ps, ProcSI, SleepMap)}
                  end,
              ?f_debug("      New backtrack: ~p\n", [NewBacktrack]),
              NewPreSI =
                  PreSI#trace_state{backtrack = NewBacktrack,
                                    sleep_map = NewSleepMap},
              lists:reverse(Acc, [StateI,NewPreSI|Rest])
      end.
  
  lookup_clock(P, ClockMap) ->
  