anchor.diff:      ok;
   correct_redundancies_3(_, [], _) ->
       {error, 'not_fix_inconsistency'};
  -correct_redundancies_3(InconsistentNodes, [Node|Rest], Metadata) ->
  +correct_redundancies_3(InconsistentNodes, [Node|_] = NodeL, Metadata) ->
       RPCKey = rpc:async_call(Node, leo_storage_api, synchronize,
                               [InconsistentNodes, Metadata]),
       Ret = case rpc:nb_yield(RPCKey, ?DEF_REQ_TIMEOUT) of
  
positive.code:               ok ->
                    ok;
                {_, Cause} ->
                      ?warn("notify_message_to_manager/3",
                            "~p", [ [{vnode_id, VNodeId},
                                     {node, Node}, {cause, Cause}] ]),
                    {error, Cause};
                timeout = Cause ->
                    {error, Cause}
  
negative.code: -spec(correct_redundancies_2(list(), list()) ->
               ok | {error, any()}).
  correct_redundancies_2(ListOfMetadata, ErrorNodes) ->
      H = case (erlang:length(ListOfMetadata) == 1) of
              true ->
                  erlang:hd(ListOfMetadata);
              false ->
                  MaxClock = lists:max([M#?METADATA.clock
                                        || {_,M} <- ListOfMetadata]),
                  {_,RetL} = lists:foldl(
                               fun({_,#?METADATA{clock = Clock}} = M, {MaxClock_1, Acc}) when Clock == MaxClock_1 ->
                                       {MaxClock_1, [M|Acc]};
                                  (_, {MaxClock_1, Acc}) ->
                                       {MaxClock_1, Acc}
                               end, {MaxClock, []}, ListOfMetadata),
                  erlang:hd(RetL)
          end,
      {_,Metadata} = H,
      ?debugVal({Metadata, ErrorNodes}),
  
      {_Dest, CorrectNodes, InconsistentNodes} =
          lists:foldl(
  