anchor.diff:                     os:cmd("mkdir data"),
                      {S, T} = eval(D),
   
  -                   List = ?T:to_list(T),
  +                   List = gb_trees:to_list(T),
   
                      List1 = [{get(S, Time, 1), V} || {Time, V} <- List],
  -                   List2 = [{unlist(mmath_bin:to_list(Vs)), Vt} || {{_ ,Vs}, Vt} <- List1],
  +                   List2 = [{unlist(Vs), Vt} || {{_ , Vs}, Vt} <- List1],
                      List3 = [true || {_V, _V} <- List2],
   
                      Fun = fun(K, V, A) ->
  -                                 [?V:encode_handoff_item(K, V) | A]
  +                                 [metric_vnode:encode_handoff_item(K, V) | A]
                            end,
                      FR = ?FOLD_REQ{foldfun=Fun, acc0=[]},
                      {async, {fold, AsyncH, _}, _, S1} =
  -                       ?V:handle_handoff_command(FR, self(), S),
  +                       metric_vnode:handle_handoff_command(FR, self(), S),
                      L = AsyncH(),
                      L1 = lists:sort(L),
  -                   {ok, C, _} = ?V:init([1]),
  +                   {ok, C, _} = metric_vnode:init([1]),
                      C1 = lists:foldl(fun(Data, SAcc) ->
  -                                            {reply, ok, SAcc1} = ?V:handle_handoff_data(Data, SAcc),
  +                                            {reply, ok, SAcc1} =
  +                                                handoff_recv(Data, SAcc),
                                               SAcc1
                                       end, C, L1),
   
                      List4 = [{get(C1, Time, 1), V} || {Time, V} <- List],
  -                   List5 = [{unlist(mmath_bin:to_list(Vs)), Vt} || {{_ ,Vs}, Vt} <- List1],
  +                   List5 = [{unlist(Vs), Vt} || {{_ , Vs}, Vt} <- List1],
                      List6 = [true || {_V, _V} <- List2],
   
  -                   {async,{fold, AsyncHc, _}, _, C2} =
  -                       ?V:handle_handoff_command(FR, self(), C1),
  +                   {async, {fold, AsyncHc, _}, _, C2} =
  +                       metric_vnode:handle_handoff_command(FR, self(), C1),
                      Lc = AsyncHc(),
                      Lc1 = lists:sort(Lc),
  -                   {async,{fold, Async, _}, _, _} =
  -                       ?V:handle_coverage({metrics, ?B}, all, self(), S1),
  +                   {async, {fold, Async, _}, _, _} =
  +                       metric_vnode:handle_coverage({metrics, ?B},
  +                                                    all, self(), S1),
                      Ms = Async(),
  -                   {async,{fold, AsyncC, _}, _, _} =
  -                       ?V:handle_coverage({metrics, ?B}, all, self(), C2),
  +                   {async, {fold, AsyncC, _}, _, _} =
  +                       metric_vnode:handle_coverage({metrics, ?B},
  +                                                    all, self(), C2),
                      MsC = AsyncC(),
   
                      Len = length(List),
   
   
  -                   ?V:terminate(normal, S1),
  -                   ?V:terminate(normal, C2),
  +                   metric_vnode:terminate(normal, S1),
  +                   metric_vnode:terminate(normal, C2),
   
                      ?WHENFAIL(io:format(user, "L: ~p /= ~p~n"
                                          "M: ~p /= ~p~n",
                                          [Lc1, L1, gb_sets:to_list(MsC),
                                           gb_sets:to_list(Ms)]),
                                Lc1 == L1 andalso
  -                             btrie:fetch_keys(MsC) == btrie:fetch_keys(Ms) andalso
  +                             fetch_keys(MsC) == fetch_keys(Ms) andalso
                                length(List1) == Len andalso
                                length(List2) == Len andalso
                                length(List3) == Len andalso
  
positive.code: %%% Helper
  %%%-------------------------------------------------------------------
  
  unlist([E]) ->
      E.
  
  setup_fn() ->
      setup(),
  
negative.code:     end.
  
  vnode() ->
      ?SIZED(Size, vnode(Size)).
  
  non_empty_list(T) ->
      ?SUCHTHAT(L, list(T), L =/= []).
  