anchor.diff:      RingSize  = length(CurRing),
       GroupSize = leo_math:ceiling(RingSize / ?DEF_NUM_OF_DIV),
   
  -    {_,_,Index,Ring} =
  +    {_,_,Ring,_} =
           lists:foldl(
  -          fun({VNodeId, _Node}, {Id, GId, IdxAcc, TblAcc}) ->
  -                  case redundancies(ETS_Tbl, VNodeId, NumOfReplicas, NumOfAwarenessL2, Members) of
  +          fun({AddrId, _Node}, {Id, GId, IdxAcc, TblAcc}) ->
  +                  case redundancies(ETS_Tbl, AddrId, NumOfReplicas, NumOfAwarenessL2, Members) of
                         {ok, #redundancies{nodes = Nodes}} ->
                             case (GId == GroupSize) of
  -                              true  -> {Id - 1, 0,
  -                                        [{Id, VNodeId}|IdxAcc], [{Id, VNodeId, Nodes}|TblAcc]};
  -                              false -> {Id - 1, GId + 1,
  -                                        IdxAcc,                 [{Id, VNodeId, Nodes}|TblAcc]}
  +                              true ->
  +                                  RingGroup = [#addrid_nodes{id = Id,
  +                                                             addr_id = AddrId,
  +                                                             nodes   = Nodes}|TblAcc],
  +                                  #addrid_nodes{id = LastId,
  +                                                addr_id = LastAddrId} = lists:last(TblAcc),
  +                                  {Id - 1, 0,
  +                                   [#ring_group{index_from = {Id, AddrId},
  +                                                index_to   = {LastId, LastAddrId},
  +                                                addrid_nodes_list = RingGroup}|IdxAcc], []};
  +                              false ->
  +                                  {Id - 1, GId + 1, IdxAcc,
  +                                   [#addrid_nodes{id = Id,
  +                                                  addr_id = AddrId,
  +                                                  nodes   = Nodes}|TblAcc]}
                             end
                     end
             end, {RingSize, 0, [], []}, lists:reverse(CurRing)),
  -    ?debugVal({Index,Ring}),
  -    {ok, {Checksum, lists:reverse(Index), length(Ring), Ring}}.
  +
  +    %% @TODO - debug (unnecessary-codes)
  +    %% lists:foreach(fun(#ring_group{index_from = From,
  +    %%                               index_to   = To,
  +    %%                               addrid_nodes_list = List}) ->
  +    %%                       ?debugVal({From, To}),
  +    %%                       lists:foreach(fun(AddrId_Nodes) ->
  +    %%                                             ?debugVal(AddrId_Nodes)
  +    %%                                     end, List)
  +    %%               end, Ring),
  +    {ok, {Checksum, Ring}}.
   
   
   %% @doc get redundancies by key.
  
positive.code:         State1 = case (R1 == CurHash) of
                       true  -> State;
                       false ->
                           {ok, {CurHash1, CurIdx, CurRingSize, CurRing}} =
                               gen_routing_table(?SYNC_MODE_CUR_RING,  N, L2, Members),
                           State#state{cur = #routing_table{checksum = CurHash1,
                                                            index    = CurIdx,
                                                            rows     = CurRingSize,
                                                            table    = CurRing}}
                   end,
          State2 = case (R2 == PrevHash) of
                       true  -> State1;
                       false ->
                           {ok, {PrevHash1, PrevIdx, PrevRingSize, PrevRing}} =
                               gen_routing_table(?SYNC_MODE_PREV_RING, N, L2, Members),
                           State1#state{prev = #routing_table{checksum = PrevHash1,
                                                              index    = PrevIdx,
                                                              rows     = PrevRingSize,
                                                              table    = PrevRing}}
                   end,
          State2
      catch _:_ ->
  
negative.code: get_state([#member{node = Node0}|T], Node1, SetL2) when Node0 /= Node1 ->
      get_state(T, Node1, SetL2).
  
  