anchor.diff:    true = code:add_pathz(code:root_dir()++"/erts/preloaded/ebin"),
     EtsTables = ets:new(ets_tables, [public]),
     Processes = ets:new(processes, [public]),
  +  wrap_all(self(), Processes),
     LoggerOptions =
       [{processes, Processes} |
        [O || O <- Options, concuerror_options:filter_options('logger', O)]
  
positive.code: %% Between scheduler and an instrumented process
  %%------------------------------------------------------------------------------
  
  get_next_event_backend(#event{actor = {_Sender, Recipient}} = Event, State) ->
    #scheduler_state{processes = Processes, timeout = _Timeout} = State,
    case ets:lookup(Processes, Recipient) =/= [] of
      true ->
        #event{event_info = EventInfo} = Event,
        #message_event{message = Message, type = Type} = EventInfo,
        %% Message delivery always succeeds
        Recipient ! {Type, Message},
        UpdatedEvent =
          receive
            {trapping, Trapping} ->
              NewEventInfo = EventInfo#message_event{trapping = Trapping},
              Event#event{event_info = NewEventInfo}
          end,
        {ok, UpdatedEvent}
      %% false ->
      %%   %% Sending to system process. Sender must wait for immediate reply!
      %%   Sender ! {system, Event},
      %%   receive
      %%     {system_reply, UpdatedEvent} -> UpdatedEvent
      %%   after
      %%     Timeout -> error(timeout)
      %%   end
    end;
  get_next_event_backend(#event{actor = Pid} = Event, State) when is_pid(Pid) ->
    Pid ! Event,
    get_next_event_backend_loop(Event, State).
  
negative.code: max_cv(D1, D2) ->
    Merger = fun(_Key, V1, V2) -> max(V1, V2) end,
    orddict:merge(Merger, D1, D2).
  
  wrap_all(Scheduler, Processes) ->
    Map =
      fun(Name) ->
          Pid = spawn_link(fun() -> loop(whereis(Name), Scheduler) end),
          ?new_named_process(Pid, Name)
      end,
    ets:insert(Processes, [Map(Name) || Name <- registered()]).
  
  loop(Wrapped, Scheduler) ->
    receive
      {message, #message{data = {Label, {From, Ref}, Request}}} ->
        erlang:send(Wrapped, {Label, {self(), Ref}, Request}),
        receive
          {Ref, Reply} -> Scheduler ! {system_reply, From, {Ref, Reply}}
        end
    end,
    loop(Wrapped, Scheduler).
  