anchor.diff:                 end,
       State2 = State#state{unknown=Unknown2},
       add_node_capabilities(Node, Capabilities, State2);
  -add_node2(Node, Capabilities, State) ->
  -    add_node_capabilities(Node, Capabilities, State).
  +add_node(Node, Capabilities, State1) ->
  +    State2 = add_node_capabilities(Node, Capabilities, State1),
  +    filter_removed_caps(Node, Capabilities, State2).
   
   %% Remove supported capabilities for a node where it no longer appears in the
   %% rings capabilities for the node.
  
positive.code: %% to determine capabilities through RPC to the node. If RPC fails, use
  %% default values. However, unresolved nodes will be marked as such and RPC
  %% re-attempted at the next server tick.
  add_node(Node, Capabilities, State1) ->
      State2 = add_node2(Node, Capabilities, State1),
      filter_removed_caps(Node, Capabilities, State2).
  
  add_node2(Node, [], State=#state{unknown=Unknown}) ->
      {Capabilities, Resolved} = query_capabilities(Node, State),
      Unknown2 = case Resolved of
                     true ->
  
negative.code:          end
       end || Member <- Members].
  
  
  %% Determine capabilities of legacy nodes based on app.config settings and
  %% the provided app-var -> mode mapping associated with capabilities when
  %% registered.
  query_capabilities(Node, State=#state{ rpc_fn = RPCFn, registered=Registered}) ->
      %% Only query results we do not already have local knowledge of
      Known = dict:from_list(get_supported(Node, State)),
      lists:mapfoldl(fun({Capability, Info}, ResolvedAcc) ->
                             {Resv, Cap} = query_capability(Node,
                                                            RPCFn,
                                                            Known,
                                                            Capability,
                                                            Info#capability.default,
  