anchor.diff:  
   pdbe_new(Pid, Vals) ->
       Entry = {Pid,
  -             element(2, lists:keyfind(message_queue_len, 1, Vals)),
  +             process_info_get(Vals, message_queue_len, 0),
                {_E = 0,_G = 0, _W = 0, _I = 0, _S = 0, _R= 0, _D = 0} %% status
               },
  -    vals_add_status(Entry, element(2, lists:keyfind(status, 1, Vals))).
  +    vals_add_status(Entry, process_info_get(Vals, status, dead_pid)).
   
   
   pdbe_add_vals(Entry, Vals) ->
  -    MQLen = element(2, lists:keyfind(message_queue_len, 1, Vals)),
  +    MQLen = process_info_get(Vals, message_queue_len, 0),
       V1 = case MQLen > 1 of
                false -> Entry;
                true -> vals_add_mqlen(Entry, MQLen)
            end,
  -    Status = element(2, lists:keyfind(status, 1, Vals)),
  +    Status = process_info_get(Vals, status, dead_pid),
       _V2 = vals_add_status(V1, Status).
   
  +readable_status(Status) ->
  +    case Status of
  +        exiting -> "E";
  +        garbage_collecting -> "G";
  +        waiting -> "W";
  +        runnable -> "R";
  +        suspended -> "S";
  +        running -> "R";
  +        dead_pid -> "D"
  +    end.
  +
  +readable_mem(0) -> "0B";
   readable_mem(Mem) ->
       case math:log(Mem)/math:log(2) of
           L when L < 10.0 ->
  -            "B";
  +            lists:flatten(io_lib:format("~p", [Mem]))
  +            ++ "B";
           L when L < 20.0 ->
               lists:flatten(io_lib:format("~p", [Mem div 1024]))
               ++ "KB";
  
positive.code:             "c" -> comm:send_local(Pid, {sort_by, cpuusage});
              "m" -> comm:send_local(Pid, {sort_by, memory});
              "t" -> comm:send_local(Pid, {toggle_exclude_self});
              "g" -> [garbage_collect(X) || X <- processes()];
              _ -> ok
      end,
      case Quit of
          quit -> ok;
          _ -> top_interactive(Pid)
      end.
  
  usage() ->
      io:format(
        "~n"
        " (q)uit, (e)val expr, (g)arb-coll."
        %% ", exclude (t)op itself" %% undocumented feature for top development
        "~n sort by: (c)pu usage (m)emory (p)ids (w)aiting messages~n").
  
  -spec on(comm:message(), state()) -> state().
  on({mon_on}, State) ->
      set_monitoring(State, true);
  
  on({output_on}, State) ->
      comm:send_local(self(), {output_data}),
      set_output(State, true);
  
  on({output_off}, State) ->
      comm:send_local(self(), {output_data}),
      set_output(State, false);
  
  on({sort_by, Type}, State) ->
      set_sort_by(State, Type);
  
  on({toggle_exclude_self}, State) ->
      toggle_exclude_self(State);
  
  on({start_mon}, State) when element(2, State) ->
      T = [ catch({X, erlang:process_info(X, [message_queue_len, status])})
            || X <- erlang:processes(), X =/= exclude_self(State) ],
  
  
negative.code: -export([top/0]).
  
  -type state() :: { pdb:tableid(),
                     false | all | pid, %% sampling: no, all or a single pid
                     false | all | pid, %% output: no, all, or a single pid
                     erlang_timestamp(), %% last output
                     non_neg_integer(), %% # of measures
                     non_neg_integer(), %% sort by
                     no_exclude | pid()
                   }.
  
  -spec start_link(list()) -> {ok, pid()}.
  start_link(Group) ->
      gen_component:start_link(?MODULE, fun ?MODULE:on/2, [],
                               [{erlang_register, ?MODULE},
                                {pid_groups_join_as, Group, ?MODULE}]).
  
  -spec init([]) -> state().
  init([]) ->
  