anchor.diff:  -spec epidemic_reply_msg(passed_state(), anypid(), anypid(), comm:message()) ->
                                   gc_mpath_msg().
   epidemic_reply_msg(PState, FromPid, ToPid, Msg) ->
  -    {'$gen_component', trace_mpath, PState, FromPid, ToPid, Msg}.
  +    {'$gen_component', trace_mpath, PState, comm:make_global(FromPid), ToPid, Msg}.
   
   -spec log_send(passed_state(), anypid(), anypid(), comm:message(), local|global|local_after) -> DeliverAlsoDirectly :: boolean().
   log_send(PState, FromPid, ToPid, Msg, LocalOrGlobal) ->
  
positive.code: -spec log_recv(passed_state(), anypid(), anypid(), comm:message()) -> ok.
  log_recv(PState, FromPid, ToPid, Msg) ->
      Now = os:timestamp(),
      case  passed_state_logger(PState) of
          io_format ->
              MsgMapFun = passed_state_msg_map_fun(PState),
              io:format("~p recv ~.0p -> ~.0p:~n  ~.0p.~n",
  
negative.code: -spec get_trace(trace_id()) -> trace().
  get_trace(TraceId) ->
      LogRaw = get_trace_raw(TraceId),
      Trace =
          [case Event of
               {log_send, Time, TraceId, Source, Dest, {Tag, Key, Hops, Msg}, LorG}
                 when Tag =:= ?lookup_aux orelse Tag =:= ?lookup_fin ->
                   {log_send, Time, TraceId,
                    normalize_pidinfo(Source),
                    normalize_pidinfo(Dest),
                    convert_msg({Tag, Key, Hops, convert_msg(Msg)}), LorG};
               {log_send, Time, TraceId, Source, Dest, Msg, LorG} ->
                   {log_send, Time, TraceId,
                    normalize_pidinfo(Source),
                    normalize_pidinfo(Dest), convert_msg(Msg), LorG};
               {log_recv, Time, TraceId, Source, Dest, {Tag, Key, Hops, Msg}}
                 when Tag =:= ?lookup_aux orelse Tag =:= ?lookup_fin ->
                   {log_recv, Time, TraceId,
                    normalize_pidinfo(Source),
                    normalize_pidinfo(Dest),
                    convert_msg({Tag, Key, Hops, convert_msg(Msg)})};
               {log_recv, Time, TraceId, Source, Dest, Msg} ->
                   {log_recv, Time, TraceId,
                    normalize_pidinfo(Source),
                    normalize_pidinfo(Dest), convert_msg(Msg)};
               {log_info, Time, TraceId, Pid, Msg} ->
                   case Msg of
                       {gc_on_done, Tag} ->
                           {log_info, Time, TraceId,
                            normalize_pidinfo(Pid),
                            {gc_on_done, util:extint2atom(Tag)}};
                       _ ->
                           {log_info, Time, TraceId,
                            normalize_pidinfo(Pid), convert_msg(Msg)}
                   end
           end || Event <- LogRaw],
      resolve_remote_pids(Trace).
  
  -spec resolve_remote_pids(Trace::trace()) -> trace().
  resolve_remote_pids(Trace) ->
      % remote pids are present in two forms (with each of them present!):
      % (a) fully resolved pidinfo() and (b) non-resolved pidinfo()
      % -> find (a) and replace (b):
      DictResolved =
          dict:from_list(
            lists:flatten(
              [begin
                   Pid1 = element(4, Event),
                   Pid2 = ?IIF(element(1, Event) =:= log_info, unknown, element(5, Event)),
                   % known pids
                   [{PidX, X} || X = {PidX, InfoX} <- [Pid1, Pid2], is_tuple(InfoX)]
               end || Event <- Trace])),
      [begin
           Pid1 = element(4, Event),
           Pid2 = ?IIF(element(1, Event) =:= log_info, unknown, element(5, Event)),
           lists:foldl(fun({I, PidX}, EventX) ->
                               case dict:find(PidX, DictResolved) of
                                   error -> EventX;
                                   {ok, Res} -> setelement(I, EventX, Res)
                               end
                       end, Event,
                       % unknown pids:
                       [{I, PidX} || {I, {PidX, InfoX}} <- [{4, Pid1}, {5, Pid2}],
                                     is_atom(InfoX)])
       end || Event <- Trace].
  
  -spec convert_msg(Msg::comm:message()) -> comm:message().
  convert_msg(Msg) when is_tuple(Msg)
  