anchor.diff:                     [?pretty_s(EarlyIndex, EarlyEvent)]),
               case
                 update_trace(
  -                EarlyEvent, Event, Clock, TraceState,
  -                Later, NewOldTrace, Rest, ObserverInfo, State)
  +                EarlyEvent, Event, Clock, EarlyTraceState,
  +                Later, UpdEarly, RevEarly, ObserverInfo, State)
               of
                 skip -> update_clock;
  -              {UpdatedNewOldTrace, ConservativeCandidates} ->
  -                {update, UpdatedNewOldTrace, ConservativeCandidates}
  +              {UpdatedNewEarly, ConservativeCandidates} ->
  +                {update, UpdatedNewEarly, ConservativeCandidates}
               end
           end
       end,
  -  NewClock =
  +  {NewClock, NewNextIndex} =
       case Action =:= none of
  -      true -> Clock;
  +      true -> {Clock, NextIndex};
         false ->
  -        MaxCV = max_cv(lookup_clock(EarlyActor, EarlyClockMap), Clock),
  -        clock_store(EarlyActor, EarlyIndex, MaxCV)
  -    end,
  -  {NewTrace, NewRest} =
  +        NC = max_cv(lookup_clock(EarlyActor, EarlyClockMap), Clock),
  +        ActorClock = lookup_clock(Actor, ClockMap),
  +        NI = find_latest_hb_index(ActorClock, NC),
  +        ?debug(State#scheduler_state.logger, "  Next @ ~w~n", [NI]),
  +        {NC, NI}
  +    end,
  +  {NewUpdEarly, NewRevEarly} =
       case Action of
  -      none -> {[TraceState|NewOldTrace], Rest};
  -      update_clock -> {[TraceState|NewOldTrace], Rest};
  -      {update, S, CI} ->
  -        maybe_log_race(TraceState, Index, Event, State),
  -        NR = add_conservative(Rest, EarlyActor, EarlyClock, CI, State),
  -        {S, NR}
  -    end,
  -  more_interleavings_for_event(NewRest, Event, Later, NewClock, State, Index, NewTrace).
  +      none -> {[EarlyTraceState|UpdEarly], RevEarly};
  +      update_clock -> {[EarlyTraceState|UpdEarly], RevEarly};
  +      {update, S, CC} ->
  +        maybe_log_race(EarlyTraceState, TraceState, State),
  +        EarlyClock = lookup_clock_value(EarlyActor, Clock),
  +        NRE = add_conservative(RevEarly, EarlyActor, EarlyClock, CC, State),
  +        {S, NRE}
  +    end,
  +  more_interleavings_for_event(TraceState, NewRevEarly, NewNextIndex, NewClock,
  +                               Later, State, NewUpdEarly).
   
   update_trace(
     EarlyEvent, Event, Clock, TraceState,
  
positive.code:   Merger = fun(_Key, V1, V2) -> max(V1, V2) end,
    orddict:merge(Merger, D1, D2).
  
  -else.
  
  empty_map() ->
  
negative.code: -record(scheduler_state, {
            assertions_only              :: boolean(),
            assume_racing                :: assume_racing_opt(),
            depth_bound                  :: pos_integer(),
            dpor                         :: concuerror_options:dpor(),
            entry_point                  :: mfargs(),
  