anchor.diff:  %%%  Patt - list(term(P))|term(P) - all terms P must match the message.
   %%%    funs, ports, refs and pids ar turned into atoms.
   %%%  CBs - list(function()) -  CB|list(CB)
  -%%%  CB - fun(F)|atom(M)|{fun(F),term(Init)}|{atom(M),term(Init)}
  +%%%  CB - fun(F)|atom(M)|{fun(F), term(Init)}|{atom(M), term(Init)}
   %%%  M - if M is '', the default callback is called. it will write the
   %%%    trace message to a file (if Init is a string) or the screen.
   %%%    otherwise, M:go(Msg,Seq,State) is called
  
positive.code: mangle_ic(MFA) ->
    case MFA of
      {proc_lib,init_p,[_,_,M,F,A]} ->
        {proc_lib, trans_init(M,F,A)};
      {file,file,[_,FileName,_]} ->
        {file, {atomize(FileName)}};
      {dets,do_open_file,[Tab,_FileName,_,_,_,_,_,_Ram,_,_,_]} ->
        {dets, {Tab}};
      {application_master,start_it,[_,{state,_,ApplD,_,_,_},_,_]} ->
        {appl_data,App,_,_,_,_,_,_,_} = ApplD,
        {application_master, {App}};
      {erlang,apply,[Fun,[]]} when is_function(Fun) ->
        funi(Fun);
      {M,F,As} ->
  
negative.code:   end;
  grep(P,T) -> grep([P],T).
  
  grp([],_) -> [];
  grp(P,[]) -> P;
  grp(P,Fun)
    when is_function(Fun) -> grp(P,list_to_atom(erlang:fun_to_list(Fun)));
  grp(P,Port)
    when is_port(Port) -> grp(P,list_to_atom(erlang:port_to_list(Port)));
  grp(P,Rf)
    when is_reference(Rf) -> grp(P,list_to_atom(erlang:ref_to_list(Rf)));
  grp(P,Pid)
    when is_pid(Pid) -> grp(P,list_to_atom(pid_to_list(Pid)));
  grp(P,T)
    when is_tuple(T) ->
    case lists:member(T,P) of
      true -> grp(P--[T],[]);
      false -> grp(P,tuple_to_list(T))
    end;
  grp(P,L)
    when is_list(L) ->
    case lists:member(L,P) of
      true -> grp(P--[L],[]);
      false -> grp(grp(P,hd(L)),tl(L))
    end;
  grp(P,T) -> grp(P--[T],[]).
  
  raw(end_of_trace,State) ->
    State;
  