anchor.diff:  get_redundancies([#member{node = Node0}|T], Node1, SetL2) when Node0 /= Node1 ->
       get_redundancies(T, Node1, SetL2).
   
  +
  +%% @doc Find redundanciess by vnodeid
  +%% @private
  +find_redundancies_by_vnode_id([],_VNodeId) ->
  +    not_found;
  +find_redundancies_by_vnode_id([#ring_group{index_from = {_,From},
  +                                           index_to   = {_,To},
  +                                           addrid_nodes_list = List}|_Rest], VNodeId) when From =< VNodeId,
  +                                                                                           To   >= VNodeId ->
  +    find_redundancies_by_vnode_id_1(List, VNodeId);
  +find_redundancies_by_vnode_id([_|Rest], VNodeId) ->
  +    find_redundancies_by_vnode_id(Rest, VNodeId).
  +
  +
  +find_redundancies_by_vnode_id_1([],_VNodeId) ->
  +    not_found;
  +find_redundancies_by_vnode_id_1([#addrid_nodes{st_addr_id = From,
  +                                               addr_id    = To,
  +                                               nodes = Nodes}|_Rest], VNodeId) when From =< VNodeId,
  +                                                                                    To   >=  VNodeId ->
  +    {ok, Nodes};
  +find_redundancies_by_vnode_id_1([_|Rest], VNodeId) ->
  +    find_redundancies_by_vnode_id_1(Rest, VNodeId).
  +
  
positive.code: -define(DEF_NUM_OF_DIV, 32).
  
  -record(addrid_nodes, {
            id = 0        :: integer(),
            addr_id = 0   :: integer(),
            next_id = 0   :: integer(),
            next_addr_id = 0 :: integer(),
            nodes         :: list(atom())
           }).
  
  -record(ring_group, {
            index_from    :: tuple(integer(),integer()),
            index_to      :: tuple(integer(),integer()),
            addrid_nodes_list :: list(#addrid_nodes{})
           }).
  
  -record(ring_info, {
            checksum = -1 :: integer(),
            ring_group_list :: list(#ring_group{})
           }).
  
  
negative.code:     %%                       lists:foreach(fun(AddrId_Nodes) ->
      %%                                             ?debugVal(AddrId_Nodes)
      %%                                     end, List)
      %%               end, lists:reverse(Ring)),
      {ok, {Checksum, lists:reverse(Ring)}}.
  
  
  %% @doc get redundancies by key.
  