anchor.diff:  			 show_output = ShowOutput} = State) ->
       NewRunCnt = RunCnt + 1,
       ?debug("\nReplay (~p) is required...\n", [NewRunCnt]),
  -    [TraceTop|TraceRest] = Trace,
  -    LidTrace = TraceTop#trace_state.lid_trace,
       concuerror_lid:stop(),
       %% Get buffered output from group leader
       %% TODO: For now just ignore it. Maybe we can print it
  
positive.code:                                               concuerror_lid:lid())],
            done      = ordsets:new()     :: ordsets:ordset(concuerror_lid:lid()),
            sleep_set = ordsets:new()     :: ordsets:ordset(concuerror_lid:lid()),
            nexts     = dict:new()        :: dict(), %% dict(concuerror_lid:lid(), instr()),
            error_nxt = []                :: [concuerror_lid:lid()],
            clock_map = empty_clock_map() :: clock_map(),
            preemptions = 0               :: non_neg_integer(),
            lid_trace = new_lid_trace()   :: queue() %% queue({transition(),
                                                     %%        clock_vector()})
           }).
  
  init_tr() ->
  	{concuerror_lid:root_lid(), init, []}.
  
  empty_clock_map() -> dict:new().
  
  new_lid_trace() ->
      queue:in({init_tr(), empty_clock_vector()}, queue:new()).
  
  empty_clock_vector() -> orddict:new().
  
  -type trace_state() :: #trace_state{}.
  
  
negative.code:         false -> ok
      end,
      proc_cleanup(processes() -- ProcBefore),
      {FirstLid, NewGroupLeader} = start_target_op(Target),
      _ = wait_next(FirstLid, init),
      NewTrace = replay_trace_aux(Trace),
      ?debug("Done replaying...\n\n"),
      %% Report the start of a new interleaving
      concuerror_log:progress({'new', NewRunCnt, SBlocked}),
      State#dpor_state{run_count = NewRunCnt, must_replay = false,
                       group_leader = NewGroupLeader, trace = NewTrace}.
  
  replay_trace_aux(Trace) ->
      [Init|Rest] = lists:reverse(Trace),
      replay_trace_aux(Rest, [Init]).
  
  replay_trace_aux([], Acc) -> Acc;
  replay_trace_aux([TraceState|Rest], Acc) ->
      #trace_state{i = _I, last = {Lid, Cmd, _} = _Last} = TraceState,
      %% ?debug(" ~-4w: ~P\n",[_I, _Last, ?DEBUG_DEPTH]),
      _Next = wait_next(Lid, Cmd),
      %% ?debug("."),
      UpdAcc = replay_update_trace(TraceState, Acc),
      %% ?debug(".\n"),
      replay_trace_aux(Rest, UpdAcc).
  
  wait_next(Lid, {exit, {normal, _Info}}) ->
      Pid = concuerror_lid:get_pid(Lid),
  