anchor.diff:  
   %%--------------------------------------------------------------------
   %% @doc
  -%% Executes test configuration many times. Returns [ValuesSums, ValuesLists, OkNum, Errors].
  +%% Executes test configuration many times.
   %% @end
   %%--------------------------------------------------------------------
   -spec exec_multiple_tests(M :: atom(), F :: atom(), Inputs :: list(),
  -    Count :: integer()) -> list().
  +    Count :: integer()) -> {ValuesSums, ValuesLists, OkNum, Errors} when
  +    ValuesSums :: list(),
  +    ValuesLists :: list(),
  +    OkNum :: integer(),
  +    Errors :: list().
   exec_multiple_tests(M, F, Inputs, Count) ->
       exec_multiple_tests(M, F, Inputs, Count, [], [], 0, []).
   
   exec_multiple_tests(_M, _F, _Inputs, 0, ValuesSums, ValuesLists, OkNum, Errors) ->
       ReversedValuesLists = lists:map(fun({K, Val}) ->
  -      {K, lists:reverse(Val)}
  +        {K, lists:reverse(Val)}
       end, ValuesLists),
  -    [ValuesSums, ReversedValuesLists, OkNum, lists:reverse(Errors)];
  +    {ValuesSums, ReversedValuesLists, OkNum, lists:reverse(Errors)};
   
   exec_multiple_tests(M, F, Inputs, Count, ValuesSums, ValuesLists, OkNum, Errors) ->
       case exec_test(M, F, Inputs) of
  -      {error, E} ->
  -        exec_multiple_tests(M, F, Inputs, Count - 1, ValuesSums, ValuesLists, OkNum, [E | Errors]);
  -      V ->
  -        case ValuesSums of
  -          [] ->
  -            InitValuesLists = lists:map(fun({K, Val}) ->
  -              {K, [Val]}
  -            end, V),
  -            exec_multiple_tests(M, F, Inputs, Count - 1, V, InitValuesLists, OkNum + 1, Errors);
  -          _ ->
  -            NewVSums = lists:zipwith(fun({K, V1}, {K, V2}) ->
  -              {K, V1 + V2}
  -            end, V, ValuesSums),
  -            NewVLists = lists:zipwith(fun({K, V1}, {K, V2}) ->
  -              {K, [V1 | V2]}
  -            end, V, ValuesLists),
  -            exec_multiple_tests(M, F, Inputs, Count - 1, NewVSums, NewVLists, OkNum + 1, Errors)
  -        end
  +        {error, E} ->
  +            exec_multiple_tests(M, F, Inputs, Count - 1, ValuesSums, ValuesLists, OkNum, [E | Errors]);
  +        V ->
  +            case ValuesSums of
  +                [] ->
  +                    InitValuesLists = lists:map(fun({K, Val}) ->
  +                        {K, [Val]}
  +                    end, V),
  +                    exec_multiple_tests(M, F, Inputs, Count - 1, V, InitValuesLists, OkNum + 1, Errors);
  +                _ ->
  +                    NewVSums = lists:zipwith(fun({K, V1}, {K, V2}) ->
  +                        {K, V1 + V2}
  +                    end, V, ValuesSums),
  +                    NewVLists = lists:zipwith(fun({K, V1}, {K, V2}) ->
  +                        {K, [V1 | V2]}
  +                    end, V, ValuesLists),
  +                    exec_multiple_tests(M, F, Inputs, Count - 1, NewVSums, NewVLists, OkNum + 1, Errors)
  +            end
       end.
   
   %%--------------------------------------------------------------------
  
positive.code:     receive
          {'EXIT', _, normal} ->
              check_links();
          {'EXIT',_,_} ->
              {error, linked_proc_error}
      after 0 ->
          ok
  
negative.code:     ConfigName :: term(), Repeats :: integer()) -> ok.
  exec_perf_config(M, F, Inputs, Ext, ConfigName, Repeats) ->
      [I1] = Inputs,  % get first arg (test config)
      {ValuesSums, ValuesLists, OkNum, Errors} = exec_multiple_tests(M, F, [I1 ++ Ext], Repeats),
      Json = case file:read_file("perf_results") of
                 {ok, FileBinary} ->
                     json_parser:parse_json_binary_to_atom_proplist(FileBinary);
                 _ ->
                     []
             end,
      {ok, File} = file:open("perf_results", [write]),
  
  
  