anchor.diff:  handle_event({_Type, GL, _Msg}, State) when node(GL) =/= node() ->
       {ok, State};
   handle_event(Event, State) ->
  -    write_event(tag_event(Event)),
  +    write_event(tag_event(Event),io),
       {ok, State}.
   
   handle_info({'EXIT', User, _Reason}, {User, PrevHandler}) ->
  
positive.code: 	 handle_event/2, handle_call/2, handle_info/2,
  	 terminate/2, code_change/3]).
  
  %% This one is used when we takeover from the simple error_logger.
  init({[], {error_logger, Buf}}) ->
      User = set_group_leader(),
      write_events(Buf),
      {ok, {User, error_logger}};
  %% This one is used if someone took over from us, and now wants to
  %% go back.
  
negative.code: tag_event(Event) ->    
      {erlang:localtime(), Event}.
  
  write_events(Events,IOMod) -> write_events1(lists:reverse(Events),IOMod).
  
  write_events1([Event|Es],IOMod) ->
      write_event(Event,IOMod),
      write_events1(Es,IOMod);
  write_events1([],_IOMod) ->
      ok.
  
  write_event({Time, {error, _GL, {Pid, Format, Args}}},IOMod) ->
      T = write_time(maybe_utc(Time)),
      case catch io_lib:format(add_node(Format,Pid), Args) of
  	S when is_list(S) ->
  	    format(IOMod, T ++ S);
  	_ ->
  	    F = add_node("ERROR: ~p - ~p~n", Pid),
  	    format(IOMod, T ++ F, [Format,Args])
      end;
  write_event({Time, {emulator, _GL, Chars}},IOMod) ->
      T = write_time(maybe_utc(Time)),
      case catch io_lib:format(Chars, []) of
  	S when is_list(S) ->
  	    format(IOMod, T ++ S);
  	_ ->
  	    format(IOMod, T ++ "ERROR: ~p ~n", [Chars])
      end;
  write_event({Time, {info, _GL, {Pid, Info, _}}},IOMod) ->
      T = write_time(maybe_utc(Time)),
      format(IOMod, T ++ add_node("~p~n",Pid),[Info]);
  write_event({Time, {error_report, _GL, {Pid, std_error, Rep}}},IOMod) ->
      T = write_time(maybe_utc(Time)),
      S = format_report(Rep),
      format(IOMod, T ++ S ++ add_node("", Pid));
  write_event({Time, {info_report, _GL, {Pid, std_info, Rep}}},IOMod) ->
      T = write_time(maybe_utc(Time), "INFO REPORT"),
      S = format_report(Rep),
      format(IOMod, T ++ S ++ add_node("", Pid));
  write_event({Time, {info_msg, _GL, {Pid, Format, Args}}},IOMod) ->
      T = write_time(maybe_utc(Time), "INFO REPORT"),
      case catch io_lib:format(add_node(Format,Pid), Args) of
  	S when is_list(S) ->
  	    format(IOMod, T ++ S);
  	_ ->
  	    F = add_node("ERROR: ~p - ~p~n", Pid),
  	    format(IOMod, T ++ F, [Format,Args])
      end;
  write_event({Time, {warning_report, _GL, {Pid, std_warning, Rep}}},IOMod) ->
      T = write_time(maybe_utc(Time), "WARNING REPORT"),
      S = format_report(Rep),
      format(IOMod, T ++ S ++ add_node("", Pid));
  write_event({Time, {warning_msg, _GL, {Pid, Format, Args}}},IOMod) ->
      T = write_time(maybe_utc(Time), "WARNING REPORT"),
      case catch io_lib:format(add_node(Format,Pid), Args) of
  	S when is_list(S) ->
  	    format(IOMod, T ++ S);
  	_ ->
  	    F = add_node("ERROR: ~p - ~p~n", Pid),
  	    format(IOMod, T ++ F, [Format,Args])
      end;
  write_event({_Time, _Error},_IOMod) ->
      ok.
  
  maybe_utc(Time) ->
  