anchor.diff:  	undefined -> 
   	    case dict:find(handler,Traci) of
   		{ok,[H]} -> H;
  -		error -> undefined
  +		error -> {fun defaulthandler/4, initial}
   	    end;
   	_ ->
   	    Handler
       end.
   
  -do_format(Fd,Details,DisableSort) ->
  -    Clients = lists:foldl(fun({FileOrWrap,Traci,Handler},Acc) ->
  -				  [start_client(FileOrWrap,Traci,Handler)
  -				   |Acc]
  +do_format(Fd,Details,DisableSort,Handler) ->
  +    EmptyHandler = {fun(_,_,_,_) -> ok end, ok},
  +    EtHandler = {{ttb_et, handler}, initial},
  +    Clients = lists:foldl(fun({FileOrWrap,Traci,et},Acc) ->
  +				  [start_client(FileOrWrap,Traci,EtHandler)|Acc];
  +                             ({FileOrWrap,Traci,_},Acc) ->
  +				  [start_client(FileOrWrap,Traci,EmptyHandler)|Acc]
   			  end,[],Details),
  -    init_collector(Fd,Clients,DisableSort).
  -
  -
  -start_client(FileOrWrap,Traci,et) ->
  -    dbg:trace_client(file, FileOrWrap, 
  -		     {fun handler/2, 
  -		      {dict:to_list(Traci),{{ttb_et,handler},initial}}});
  -start_client(FileOrWrap,Traci,undefined) ->
  -    dbg:trace_client(file, FileOrWrap, 
  -		     {fun handler/2, 
  -		      {dict:to_list(Traci),{fun defaulthandler/4,initial}}});
  +    init_collector(Fd,Clients,DisableSort,Handler).
  +
  +
   start_client(FileOrWrap,Traci,Handler) ->
       dbg:trace_client(file, FileOrWrap, 
  -		     {fun handler/2, {dict:to_list(Traci),Handler}}).
  -
  +		     {fun handler/2, {dict:to_list(Traci), Handler}}).
   handler(Trace,State) ->
       %% State here is only used for the initial state. The accumulated
       %% State is maintained by collector!!!
  
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: 	      _ -> standard_io
  	  end,
      Handler = case lists:keysearch(handler,1,Opt) of
                    {value,{handler,H}} -> H;
                    _ -> {fun defaulthandler/4, initial}
  	  end,
      DisableSort = proplists:get_value(disable_sort, Opt, false),
      {Out,Handler,DisableSort};
  