anchor.diff:                       Pid = element(1, X),
                        pdb:delete(Pid, TableName),
                        %% plot data is:
  -                     Status = try element(2, process_info(Pid, status))
  -                              catch _:_ -> dead_pid
  -                              end,
  +                     Infos = try_process_info(Pid, [status, memory, stack_size]),
  +                     Status = process_info_get(Infos, status, dead_pid),
                        {vals_pid(X),
                         Status,
                         vals_mqlen(X)/Count,
                         vals_cpu_usage(X, Count),
  -                      try element(2, process_info(Pid, memory))
  -                      catch _Level2:_Reason2 -> 0
  -                      end}
  +                      process_info_get(Infos, memory, 0),
  +                      process_info_get(Infos, stack_size, 0)}
                    end || X <- R1, is_tuple(X), is_pid(element(1, X)) ],
       SortedPlotData = lists:keysort(sort_by(State), PlotData),
       L = length(SortedPlotData),
  
positive.code:                   pdb:set(V1, TableName)
            end
        end || {P, NewVals} <- T, is_pid(P), undefined =/= NewVals],
      comm:send_local_after(1, self(), {start_mon}),
      inc_counter(State);
  on({start_mon}, State) -> State;
  
  on({output_data}, State) when element(3, State) ->
      TableName = table(State),
      %%Now = os:timestamp(),
      %%Delay = timer:now_diff(Now, timestamp(State)) / 1000000,
      Count = counter(State),
      ProcsMem = erlang:memory(processes),
      ProcsMemUsed = erlang:memory(processes_used),
  
negative.code:     catch _:_ -> ok
      end,
      {pdb:new(?MODULE, [set, protected]), false, false,
       os:timestamp(), 0, _SortBy = 4, self()}.
  
  -spec top() -> ok.
  top() ->
      io:format("~p~n", [io:rows(standard_io)]),
      Pid = pid_groups:find_a(?MODULE),
      comm:send_local(Pid, {enable_sampling, all}),
      comm:send_local(Pid, {sample_all}),
      comm:send_local(Pid, {enable_output, all}),
      comm:send_local(Pid, {output_all}),
      top_interactive(Pid).
  
  top_interactive(Pid) ->
      {ok, [Char]} = io:fread("> ", "~c"),
      Quit =
          case Char of
              "q" -> quit;
              "e" ->
                  comm:send_local(Pid, {output_off}),
                  Expr = io:parse_erl_exprs('expr>'),
                  comm:send_local(Pid, {enable_output, all}),
                  comm:send_local(Pid, {output_all}),
                  case element(1, Expr) of
                      ok ->
                          spawn(fun() -> erl_eval:exprs(element(2, Expr), erl_eval:new_bindings()) end),
  