anchor.diff:      %%                                     end, List)
       %%               end, lists:reverse(Ring)),
       {ok, {Checksum, lists:reverse(Ring)}}.
  +
  +
  +gen_routing_table_1({ok, #redundancies{nodes = Nodes}},
  +                    GroupSize, Id, AddrId, GId, IdxAcc, TblAcc, StAddrId) ->
  +    Id1 = Id + 1,
  +    case (GId == GroupSize) of
  +        true ->
  +            RingGroup = [#addrid_nodes{id = Id1,
  +                                       addr_id_to   = AddrId,
  +                                       addr_id_from = StAddrId,
  +                                       nodes = Nodes}|TblAcc],
  +
  +            #addrid_nodes{id = FirstId,
  +                          addr_id_to = FirstAddrId} = lists:last(TblAcc),
  +            FirstAddrId_1 = case FirstId of
  +                                1 -> 0;
  +                                _ -> FirstAddrId
  +                            end,
  +
  +            {Id1, 0, [#ring_group{index_from = FirstAddrId_1,
  +                             index_to   = AddrId,
  +                             addrid_nodes_list = lists:reverse(RingGroup)}|IdxAcc],
  +             [], AddrId + 1};
  +        false ->
  +            {Id1, GId + 1, IdxAcc,
  +             [#addrid_nodes{id = Id1,
  +                            addr_id_to   = AddrId,
  +                            addr_id_from = StAddrId,
  +                            nodes        = Nodes}|TblAcc], AddrId + 1}
  +    end;
  +gen_routing_table_1(_,_GroupSize, AddrId, Id, GId, IdxAcc, TblAcc,_StAddrId) ->
  +    error_logger:warning_msg("~p,~p,~p,~p~n",
  +                             [{module, ?MODULE_STRING}, {function, "gen_routing_table_1/8"},
  +                              {line, ?LINE}, {body, "Could not get redundancies"}]),
  +    {Id + 1, GId + 1, IdxAcc, [#addrid_nodes{}|TblAcc], AddrId + 1}.
   
   
   %% @doc get redundancies by key.
  
positive.code: %% @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);
  
negative.code: -define(DEF_NUM_OF_DIV, 32).
  
  -record(addrid_nodes, {
            id = 0            :: integer(),
            addr_id_from = 0  :: integer(),
            addr_id_to = 0    :: integer(),
            nodes             :: list(atom())
           }).
  
  -record(ring_group, {
            index_from        :: integer(),
            index_to          :: integer(),
            addrid_nodes_list :: list(#addrid_nodes{})
           }).
  
  -record(ring_info, {
            checksum = -1     :: integer(),
            ring_group_list   :: list(#ring_group{})
           }).
  
  -record(state, {
  