anchor.diff:  %%--------------------------------------------------------------------
   -spec check_links() -> ok | {error, term()}.
   check_links() ->
  -  receive
  -    {'EXIT', _, normal} ->
  -      check_links();
  -    {'EXIT',_,_} ->
  -      {error, linked_proc_error}
  -  after 0 ->
  -    ok
  -  end.
  +    receive
  +        {'EXIT', _, normal} ->
  +            check_links();
  +        {'EXIT',_,_} ->
  +            {error, linked_proc_error}
  +    after 0 ->
  +        ok
  +    end.
   
   %%--------------------------------------------------------------------
   %% @doc
  
positive.code: %% annotated function inside.
  %% @end
  %%--------------------------------------------------------------------
  -spec around_advice(#annotation{}, M :: atom(), F :: atom(), Inputs :: list()) -> Result :: term().
  around_advice(#annotation{data = {perf_cases, Cases}}, M, F, Inputs) ->
    case os:getenv("perf_test") of
      "true" ->
        Cases;
      _ ->
        annotation:call_advised(M, F, Inputs)
    end;
  
  around_advice(#annotation{data = {_, _} = SingleExt}, M, F, Inputs) ->
    around_advice(#annotation{data=[SingleExt]}, M, F, Inputs);
  
  around_advice(#annotation{data = ConfExt}, M, F, Inputs) when is_list(ConfExt)->
    case os:getenv("perf_test") of
      "true" ->
        process_flag(trap_exit, true),
        Repeats = proplists:get_value(repeats, ConfExt, 1),
        case proplists:get_value(perf_configs, ConfExt, []) of
          [] ->
            Ext = proplists:get_value(perf_config, ConfExt, []),
            exec_perf_config(M, F, Inputs, Ext, Repeats);
          Exts ->
            lists:foreach(
              fun(Ext) -> exec_perf_config(M, F, Inputs, Ext, Repeats) end,
            Exts)
        end;
      _ ->
        Ext = proplists:get_value(ct_config, ConfExt, []),
        [I1] = Inputs,  % get first arg (test config)
        annotation:call_advised(M, F, [I1 ++ Ext])
    end;
  
  around_advice(#annotation{}, M, F, Inputs) ->
    around_advice(#annotation{data=[]}, M, F, Inputs).
  
  %%%===================================================================
  %%% Internal functions
  
negative.code: %% @end
  %%--------------------------------------------------------------------
  -spec prepare_to_write(Input :: term()) -> tuple().
  prepare_to_write({struct, List}) ->
      prepare_to_write(List);
  
  prepare_to_write(Input) when is_list(Input) ->
      {struct, lists:map(fun(I) -> prepare_to_write(I) end, Input)};
  
  prepare_to_write({K, V}) when is_list(V) ->
      {K, prepare_to_write(V)};
  
  prepare_to_write({K, V}) ->
      {K, V}.
  