anchor.diff:      {stop, normal, ok, State};
   
   
  +handle_call({lookup, Tbl,_VNodeId},_From, State) when Tbl /= ?CUR_RING_TABLE,
  +                                                      Tbl /= ?PREV_RING_TABLE ->
  +    {reply, {error, invalid_table}, State};
  +
   handle_call({lookup, Tbl, VNodeId},_From, State) ->
       ?debugVal({Tbl, VNodeId}),
       Reply = ok,
  
positive.code: get_redundancies([],_Node1,_) ->
      not_found;
  get_redundancies([#member{node        = Node0,
                     grp_level_2 = L2}|_], Node1, SetL2) when Node0 == Node1  ->
      case lists:member(L2, SetL2) of
          false ->
              {Node0, [L2|SetL2]};
  
negative.code:     {reply, Reply, State};
  
  
  handle_call({last, Tbl},_From, State) when Tbl /= ?CUR_RING_TABLE,
                                             Tbl /= ?PREV_RING_TABLE ->
      {reply, {error, invalid_table}, State};
  handle_call({last, Tbl},_From, #state{cur  = Cur,
                                        prev = Prev} = State) ->
      Fun = fun (_RingGroupList) ->
                    case _RingGroupList of
                        [] ->
                            not_found;
                        _ ->
                            #ring_group{
                               addrid_nodes_list = AddrId_Nodes} = lists:last(_RingGroupList),
                            case AddrId_Nodes of
                                [] ->
                                    not_found;
                                _ ->
                                    #addrid_nodes{nodes = Nodes} = lists:last(AddrId_Nodes),
                                    {ok, Nodes}
                            end
                    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};
  
  
  handle_call({force_sync, Tbl},_From, State) when Tbl /= ?CUR_RING_TABLE,
                                                   Tbl /= ?PREV_RING_TABLE ->
      {reply, {error, invalid_table}, State};
  
  handle_call({force_sync, Tbl},_From, State) ->
      Version = case Tbl of
  