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:                   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),
  