anchor.diff:                  last_ring_id :: term(),
                   supported :: [{node(), [{capability(), [mode()]}]}],
                   unknown :: [node()],
  -                negotiated :: [{capability(), mode()}],
  -                rpc_fn =
  -                    fun(Node, App, Var) ->
  -                        riak_core_util:safe_rpc(Node, application, get_env, [App, Var])
  -                    end
  +                negotiated :: [{capability(), mode()}]
                  }).
   
   -define(ETS, riak_capability_ets).
  
positive.code:                            {Cap, ResolvedAcc and Resv}
                     end, true, Registered).
  
  query_capability(Node, RPCFn, Known, Capability, DefaultSup, LegacyVar) ->
      case dict:find(Capability, Known) of
          {ok, Supported} ->
              {true, {Capability, Supported}};
          error ->
              query_capability(Node, RPCFn, Capability, DefaultSup, LegacyVar)
      end.
  
  query_capability(_, _, Capability, DefaultSup, undefined) ->
      Default = {Capability, [DefaultSup]},
      {true, Default};
  query_capability(Node, RPCFn, Capability, DefaultSup, {App, Var, Map}) ->
      Default = {Capability, [DefaultSup]},
      Result = RPCFn(Node,App, Var),
      case Result of
          {badrpc, _} ->
              {false, Default};
  
negative.code: %% 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{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,
                                                            Known,
                                                            Capability,
                                                            Info#capability.default,
  