anchor.diff:  	      _ -> standard_io
   	  end,
       Handler = case lists:keysearch(handler,1,Opt) of
  -	      {value,{handler,H}} -> H;
  -	      _ -> undefined
  +                  {value,{handler,H}} -> H;
  +                  _ -> {fun defaulthandler/4, initial}
   	  end,
       DisableSort = proplists:get_value(disable_sort, Opt, false),
       {Out,Handler,DisableSort};
  
positive.code: handler1(Trace,{Fd,{Traci,{{M,F},State}}}) when is_atom(M), is_atom(F) ->
      {Traci,{{M,F},M:F(Fd,Trace,Traci,State)}}.
  
  defaulthandler(Fd,Trace,_Traci,initial) ->
      dbg:dhandler(Trace,Fd);
  defaulthandler(_Fd,Trace,_Traci,State) ->
      dbg:dhandler(Trace,State).
  
  init_collector(Fd,Clients,DisableSort) ->
      Collected = get_first(Clients),
      case DisableSort of
          true -> collector(Fd,Collected, DisableSort);
          false -> collector(Fd,sort(Collected), DisableSort)
      end.
  
  collector(Fd,[{_,{Client,{Trace,State}}} |Rest], DisableSort) ->
      Trace1 = update_procinfo(Trace),
      State1 = handler1(Trace1,{Fd,State}),
      case get_next(Client,State1) of
  	end_of_trace -> 
  	    handler1(end_of_trace,{Fd,State1}),
  	    collector(Fd,Rest,DisableSort);
  	Next -> case DisableSort of
                      false -> collector(Fd,sort([Next|Rest]), DisableSort);
                      true -> collector(Fd,[Next|Rest], DisableSort)
                  end
      end;
  collector(_Fd,[], _) ->
      ok.
  
  update_procinfo({drop,_N}=Trace) ->
  
negative.code:     Details = lists:foldl(fun(File,Acc) -> [prepare(File,Handler)|Acc] end,
  			  [],Files),
      Fd = get_fd(Out),
      R = do_format(Fd,Details,DisableSort,Handler),
      file:close(Fd),
      ets:delete(?MODULE),
      case StopDbg of
  