anchor.diff:      {Tab, [calculate_tab_func_statistics(FuncStat) || FuncStat <- FuncStats]}.
       
   calculate_tab_func_statistics({Func, TimeProbes}) ->
  -    StatsKey = [min, max, median, {percentile, [75, 90, 95, 99, 999]}],
  -    Stats = bear:get_statistics_subset(TimeProbes, StatsKey),
  -    #{<<"func">> => namify(Func), <<"time">> => stats_to_map(Stats), 
  +    #{<<"func">> => namify(Func), <<"max_time">> => max(TimeProbes), 
         <<"count">> => erlang:length(TimeProbes)}.
   
  +split_traces_by_pid(Traces) ->
  +    split_traces_by(Traces, 1).
  +
   split_traces_by_tab(Traces) ->
  -    TracesUniqueTabs = lists:ukeysort(2, Traces),
  -    Tabs = lists:map(fun({_, T, _, _}) -> T end, TracesUniqueTabs),
  -    Splitted = [lists:partition(fun({_, T, _, _}) -> T =:= PT end, Traces) ||
  -                   PT <- Tabs],
  -    lists:map(fun({S, _NS}) -> S end, Splitted).
  -
  -split_traces_by_pid(Traces) ->
  -    TracesUniquePids = lists:ukeysort(1, Traces),
  -    Pids = lists:map(fun({Pid, _, _, _}) -> Pid end, TracesUniquePids),
  -    Splitted = [lists:partition(fun({Pid, _, _, _}) -> Pid =:= PPid end, Traces) ||
  -        PPid <- Pids],
  -    lists:map(fun({S, _NS}) -> S end, Splitted).
  +    split_traces_by(Traces, 2).
   
   split_traces_by_func(Traces) ->
  -    TracesUniqueFuncs = lists:ukeysort(3, Traces),
  -    Funcs = lists:map(fun({_, _, Func, _}) -> Func end, TracesUniqueFuncs),
  -    Splitted = [lists:partition(fun({_, _, Func, _}) -> Func =:= PFunc end, 
  -                                Traces) || PFunc <- Funcs],
  +    split_traces_by(Traces, 3).
  +
  +split_traces_by(Traces, ElemNum) ->
  +    TracesUnique = lists:ukeysort(ElemNum, Traces),
  +    KeysUnique = lists:map(fun(T) -> element(ElemNum, T) end, TracesUnique),
  +    Splitted = [lists:partition(fun(T) -> element(ElemNum, T) =:= KU end, 
  +                                Traces) || KU <- KeysUnique],
       lists:map(fun({S, _NS}) -> S end, Splitted).
   
   format_traces_TFT(TraceLists) ->
  
positive.code:     List = erlang:float_to_list(Float, [{decimals, Pos}]),
      erlang:list_to_float(List).
  
  namify_val(Val) when is_atom(Val) ->
      namify(Val);
  namify_val(Val) ->
  
negative.code: namify(Name) ->
      epl_viz_map:namify(Name).
  
  proplist_to_map(Proplist) ->
      lists:foldl(fun({Prop, Val}, Map) -> maps:put(namify(Prop), namify_val(Val), 
                                                    Map) end, #{}, Proplist).
  