anchor.diff:      Checksum  = erlang:crc32(term_to_binary(CurRing)),
       RingSize  = length(CurRing),
       GroupSize = leo_math:ceiling(RingSize / ?DEF_NUM_OF_DIV),
  -    {FirstAddrId,_} = lists:nth(1, CurRing),
   
       {_,_,Ring,_,_} =
           lists:foldl(
  -          fun({AddrId, _Node}, {Id1, GId, IdxAcc, TblAcc, {NextId, NextAddrId}}) ->
  +          fun({AddrId, _Node}, {Id1, GId, IdxAcc, TblAcc, StAddrId}) ->
                     case redundancies(ETS_Tbl, AddrId, NumOfReplicas, NumOfAwarenessL2, Members) of
                         {ok, #redundancies{nodes = Nodes}} ->
  -                          Id2 = Id1 - 1,
  -                          NextId1 = case NextId of
  -                                        0 -> RingSize;
  -                                        _ -> NextId
  -                                    end,
  +                          Id2 = Id1 + 1,
   
                             case (GId == GroupSize) of
                                 true ->
                                     RingGroup = [#addrid_nodes{id = Id1,
                                                                addr_id = AddrId,
  -                                                             next_id = NextId1,
  -                                                             next_addr_id = NextAddrId,
  +                                                             st_addr_id = StAddrId,
                                                                nodes        = Nodes}|TblAcc],
  -                                  #addrid_nodes{id = LastId,
  -                                                addr_id = LastAddrId} = lists:last(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 = {Id1, AddrId},
  -                                                index_to   = {LastId, LastAddrId},
  -                                                addrid_nodes_list = RingGroup}|IdxAcc], [], {NextId1 -1, AddrId}};
  +                                   [#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,
  -                                                  next_id = NextId1,
  -                                                  next_addr_id = NextAddrId,
  -                                                  nodes        = Nodes}|TblAcc], {NextId1 -1, AddrId}}
  +                                                  st_addr_id = StAddrId,
  +                                                  nodes        = Nodes}|TblAcc], AddrId + 1}
                             end
                     end
  -          end, {RingSize, 0, [], [], {1, FirstAddrId}}, lists:reverse(CurRing)),
  +          end, {1, 0, [], [], 0}, CurRing),
   
       %% @TODO - debug (unnecessary-codes)
       %% lists:foreach(fun(#ring_group{index_from = From,
  
positive.code: get_redundancies([#member{node = Node0}|T], Node1, SetL2) when Node0 /= Node1 ->
      get_redundancies(T, Node1, SetL2).
  
  
negative.code:                                                       Tbl /= ?PREV_RING_TABLE ->
      {reply, {error, invalid_table}, State};
  
  handle_call({lookup, Tbl, VNodeId},_From, #state{cur  = Cur,
                                                   prev = Prev} = State) ->
      Fun = fun (_RingGroupList) ->
                    case _RingGroupList of
                        [] ->
                            not_found;
                        _ ->
                            find_redundancies_by_vnode_id(_RingGroupList, VNodeId)
                    end
            end,
  
      Reply = case Tbl of
                  ?CUR_RING_TABLE ->
                      #ring_info{ring_group_list = RingGroupList} = Cur,
                      Fun(RingGroupList);
                  ?PREV_RING_TABLE ->
                      #ring_info{ring_group_list = RingGroupList} = Prev,
                      Fun(RingGroupList)
              end,
      {reply, Reply, State};
  
  
  