anchor.diff:  
   mk_ext_ref({NodeName, Creation}, Numbers) ->
       erts_test_utils:mk_ext_ref({NodeName, Creation}, Numbers).
  +
  +
  +t_copy_shared(_Config) ->
  +    rand:seed(default),
  +    io:format("*** SEED: ~p ***\n", [rand:export_seed()]),
  +
  +    [copy_shared_term_1(N div 10, CL) || N <- lists:seq(1,100),
  +                                         CL <- [false, true]],
  +    ok.
  +
  +copy_shared_term_1(Size, CopyLit) ->
  +    Term = rand_term(Size),
  +
  +    %% Note: Printing Term may suppress test failure
  +    %%       as it sends a copy to io-server.
  +    %%io:format("rand_term(~p): ~p\n", [Size, printable(Term)]),
  +
  +    Binary = term_to_binary(Term),
  +    Copy = erts_debug:copy_shared(Term, CopyLit),
  +    test_eq(Term, Copy),
  +    copy_shared_term_2(Copy, Binary).
  +
  +copy_shared_term_2(Copy, Binary) ->
  +    erlang:garbage_collect(),
  +    BinCopy = binary_to_term(Binary),
  +    test_eq(Copy, BinCopy),
  +    ok.
  +
  +test_eq(A, B) ->
  +    case A of
  +        B -> ok;
  +        _ -> test_eq_fail("FAILED MATCH", A, B)
  +    end,
  +    case A == B of
  +        true -> ok;
  +        false -> test_eq_fail("FAILED EQUALITY", A, B)
  +    end.
  +
  +test_eq_fail(Error, A, B) ->
  +    io:format("~s:\n\nA = ~p\n\nB = ~p\n",
  +              [Error, printable(A), printable(B)]),
  +    ct:fail(Error).
  +
  +rand_term(Size) ->
  +    F = rand:uniform(100), % to produce non-literals
  +    Big = 666_701_523_687_345_689_643 * F,
  +    MagicRef = atomics:new(10,[]),
  +    Leafs = {atom, 42, 42.17*F,
  +             Big, -Big,
  +             [], {}, #{},
  +             "literal cons",
  +             {"literal boxed"},
  +             fun lists:sort/1,
  +             fun() -> F end,
  +             self(),
  +             lists:last(erlang:ports()),
  +             make_ref(),
  +             MagicRef,
  +             <<F:(8*10)>>,    % HeapBin
  +             <<F:(8*65)>>,    % ProcBin
  +             <<F:7>>,         % SubBin + HeapBin
  +             <<F:(8*80+1)>>,  % SubBin + ProcBin
  +             mk_ext_pid({a@b, 17}, 17, 42),
  +             mk_ext_port({a@b, 21}, 13),
  +             mk_ext_ref({a@b, 42}, [42, 19, 11])},
  +    rand_term(Leafs, Size).
  +
  +rand_term(Leafs, Arity) when Arity > 0 ->
  +    Length = rand:uniform(Arity),
  +    List = [rand_term(Leafs, Arity-Length) || _ <- lists:seq(1,Length)],
  +    case rand:uniform(6) of
  +        1 -> List;
  +        2 -> list_to_improper_list(List);
  +        3 -> list_to_tuple(List);
  +        4 -> list_to_flatmap(List);
  +        5 -> list_to_hashmap(List);
  +        6 -> list_to_fun(List)
  +    end;
  +rand_term(Leafs, 0) ->
  +    element(rand:uniform(size(Leafs)), Leafs).
  +
  +list_to_improper_list([A,B|T]) ->
  +    T ++ [A|B];
  +list_to_improper_list([H]) ->
  +    [[]|H].
  +
  +list_to_flatmap(List) ->
  +    list_to_map(List, #{}).
  +
  +list_to_hashmap(List) ->
  +    HashMap = #{1=>1, 2=>2, 3=>3, 4=>4, 5=>5, 6=>6, 7=>7, 8=>8, 9=>9,10=>0,
  +                11=>1,12=>2,13=>3,14=>4,15=>5,16=>6,17=>7,18=>8,19=>9,20=>0,
  +                21=>1,22=>2,23=>3,24=>4,25=>5,26=>6,27=>7,28=>8,29=>9,30=>0,
  +                31=>1,32=>2,33=>3},
  +    list_to_map(List, HashMap).
  +
  +list_to_map([], Map) ->
  +    Map;
  +list_to_map([K], Map) ->
  +    Map#{K => K};
  +list_to_map([K,V|T], Map) ->
  +    list_to_map(T, Map#{K => V}).
  +
  +list_to_fun([X]) ->
  +    fun(A) -> A + X end;
  +list_to_fun([X, Y]) ->
  +    fun(A) -> A + X + Y end;
  +list_to_fun([X, Y | T]) ->
  +    fun(A) -> [A+X+Y | T] end.
  +
  +
  +%% Convert local funs to maps to show fun environment
  +printable(Fun) when is_function(Fun) ->
  +    case erlang:fun_info(Fun, type) of
  +        {type,local} ->
  +            {env, Env} = erlang:fun_info(Fun, env),
  +            #{'fun' => [printable(T) || T <- Env]};
  +        {type,external} ->
  +            Fun
  +    end;
  +printable([H|T]) ->
  +    [printable(H)|printable(T)];
  +printable(Tuple) when is_tuple(Tuple) ->
  +    list_to_tuple(printable(tuple_to_list(Tuple)));
  +printable(Map) when is_map(Map) ->
  +    maps:from_list(printable(maps:to_list(Map)));
  +printable(Leaf) ->
  +    Leaf.
  
positive.code: -export([all/0, suite/0, groups/0,
           test_size/1,flat_size_big/1,df/1,term_type/1,
           instructions/1, stack_check/1, alloc_blocks_size/1,
           interpreter_size_bench/1]).
  
  -export([do_alloc_blocks_size/0]).
  
  suite() ->
      [{ct_hooks,[ts_install_cth]},
  
negative.code: 
  all() -> 
      [test_size, flat_size_big, df, instructions, term_type,
       t_copy_shared,
       stack_check, alloc_blocks_size].
  
  groups() -> 
  