anchor.diff:  -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())
  +          id = 0         :: integer(),
  +          st_addr_id = 0 :: integer(),
  +          addr_id = 0    :: integer(),
  +          nodes          :: list(atom())
            }).
   
   -record(ring_group, {
  -          index_from    :: tuple(integer(),integer()),
  -          index_to      :: tuple(integer(),integer()),
  +          index_from     :: tuple(integer(),integer()),
  +          index_to       :: tuple(integer(),integer()),
             addrid_nodes_list :: list(#addrid_nodes{})
            }).
   
   -record(ring_info, {
  -          checksum = -1 :: integer(),
  +          checksum = -1   :: integer(),
             ring_group_list :: list(#ring_group{})
            }).
   
  
positive.code:             {ok, Value}
      end.
  
  %% @doc Retrieve a member from an argument.
  %% @private
  get_redundancies([],_Node1,_) ->
  
negative.code:     Checksum  = erlang:crc32(term_to_binary(CurRing)),
      RingSize  = length(CurRing),
      GroupSize = leo_math:ceiling(RingSize / ?DEF_NUM_OF_DIV),
  
      {_,_,Ring,_,_} =
          lists:foldl(
            fun({AddrId, _Node}, {Id1, GId, IdxAcc, TblAcc, StAddrId}) ->
                    case redundancies(ETS_Tbl, AddrId, NumOfReplicas, NumOfAwarenessL2, Members) of
                        {ok, #redundancies{nodes = Nodes}} ->
                            Id2 = Id1 + 1,
  
                            case (GId == GroupSize) of
                                true ->
                                    RingGroup = [#addrid_nodes{id = Id1,
                                                               addr_id = AddrId,
                                                               st_addr_id = StAddrId,
                                                               nodes        = Nodes}|TblAcc],
                                    #addrid_nodes{id = FirstId,
                                                  addr_id = FirstAddrId} = lists:last(TblAcc),
                                    FirstAddrId_1 = case FirstId of
                                                        1 -> 0;
                                                        _ -> FirstAddrId
                                                    end,
  
                                    {Id2, 0,
                                     [#ring_group{index_from = {FirstId, FirstAddrId_1},
                                                  index_to   = {Id1, AddrId},
                                                  addrid_nodes_list = lists:reverse(RingGroup)}|IdxAcc], [], AddrId + 1};
                                false ->
                                    {Id2, GId + 1, IdxAcc,
                                     [#addrid_nodes{id = Id1,
                                                    addr_id = AddrId,
                                                    st_addr_id = StAddrId,
                                                    nodes        = Nodes}|TblAcc], AddrId + 1}
                            end
                    end
            end, {1, 0, [], [], 0}, CurRing),
  
      %% @TODO - debug (unnecessary-codes)
      %% lists:foreach(fun(#ring_group{index_from = From,
  