anchor.diff:              end
       end.
   
  -fprof_dump_proc_stream({trace_ts, _Ps, call, MFA, {cp, CallerMFA}, Ts}, #dump{stack=[]} = State) ->
  +trace_proc_stream({trace_ts, _Ps, call, MFA, {cp, CallerMFA}, Ts}, #dump{stack=[]} = State) ->
       new_state(State, [MFA, CallerMFA], Ts);
   
  -fprof_dump_proc_stream({trace_ts, _Ps, call, MFA, {cp, MFA}, Ts}, #dump{stack=[MFA|Stack]} = State) ->
  +trace_proc_stream({trace_ts, _Ps, call, MFA, {cp, MFA}, Ts}, #dump{stack=[MFA|Stack]} = State) ->
       new_state(State, [MFA|Stack], Ts); % collapse tail recursion
   
  -fprof_dump_proc_stream({trace_ts, _Ps, call, MFA, {cp, CpMFA}, Ts}, #dump{stack=[CpMFA|Stack]} = State) ->
  +trace_proc_stream({trace_ts, _Ps, call, MFA, {cp, CpMFA}, Ts}, #dump{stack=[CpMFA|Stack]} = State) ->
       new_state(State, [MFA, CpMFA|Stack], Ts);
   
  -fprof_dump_proc_stream({trace_ts, _Ps, call, _MFA, {cp, _}, _Ts} = TraceTs, #dump{stack=[_|StackRest]} = State) ->
  -    fprof_dump_proc_stream(TraceTs, State#dump{stack=StackRest});
  +trace_proc_stream({trace_ts, _Ps, call, _MFA, {cp, _}, _Ts} = TraceTs, #dump{stack=[_|StackRest]} = State) ->
  +    trace_proc_stream(TraceTs, State#dump{stack=StackRest});
   
  -fprof_dump_proc_stream({trace_ts, _Ps, T, _Args, _Ts} = TraceTs, State) ->
  +trace_proc_stream({trace_ts, _Ps, T, _Args, _Ts} = TraceTs, State) ->
       case T of
           out -> ignore;
           in -> ignore;
  
positive.code:         gc_end -> ignore;
          getting_unlinked -> ignore;
          return_to -> ignore;
          _ -> io:format("fprof_dump_proc_stream: unknown trace: ~p~n", [TraceTs])
      end,
      State;
  
  fprof_dump_proc_stream(TraceTs, State) ->
      io:format("fprof_dump_proc_stream: unknown trace: ~p~n", [TraceTs]),
      State.
  
  stack_collapse(Stack) ->
      intercalate(";", [[atom_to_binary(M, utf8), <<":">>, atom_to_binary(F, utf8), <<"/">>, integer_to_list(A)] || {M, F, A} <- Stack]).
  
  dump_to_iolist(Pid, #dump{acc=Acc}) ->
      [[pid_to_list(Pid), <<";">>, stack_collapse(S), <<"\n">>] || S <- Acc].
  
  intercalate(Sep, Xs) -> lists:concat(intersperse(Sep, Xs)).
  
  
negative.code:                 error -> #dump{}
              end,
  
              NewPidState = trace_proc_stream(Term, PidState),
  
              D1 = dict:erase(PidS, State),
              D2 = dict:append(PidS, NewPidState, D1),
              trace_listener(D2)
      end.
  
  us({Mega, Secs, Micro}) ->
  