anchor.diff:      {reply, {ok, Key}, State};
   process_response(#request{msg = #rpbputreq{bucket = Bucket, key = Key}},
                    #rpbputresp{content = RpbContents, vclock = Vclock,
  -                     key = NewKey}, State) ->
  +                             key = NewKey}, State) ->
       Contents = riak_pb_kv_codec:decode_contents(RpbContents),
       ReturnKey = case NewKey of
                       undefined -> Key;
  
positive.code: 
  process_response(#request{msg = #rpbindexreq{}}, rpbindexresp, State) ->
      {reply, {ok, []}, State};
  process_response(#request{msg = #rpbindexreq{return_terms=true}}, #rpbindexresp{results=Results}, State) ->
      {reply, {ok, Results}, State};
  process_response(#request{msg = #rpbindexreq{}}, #rpbindexresp{keys=Keys}, State) ->
  
negative.code:     Timeout = proplists:get_value(timeout, Opts, default_timeout(get_index_timeout)),
      CallTimeout = proplists:get_value(call_timeout, Opts, default_timeout(get_index_call_timeout)),
      ReturnTerms = proplists:get_value(return_terms, Opts),
      MaxResults = proplists:get_value(max_results, Opts),
      Stream = proplists:get_value(stream, Opts, false),
  
      Req = #rpbindexreq{bucket=Bucket, index=Index, qtype=range,
                         range_min=encode_2i(StartKey),
                         range_max=encode_2i(EndKey),
                         return_terms=ReturnTerms,
                         max_results=MaxResults,
                         stream=Stream},
      Call = case Stream of
                 true ->
                     ReqId = mk_reqid(),
                     {req, Req, Timeout, {ReqId, self()}};
                 false ->
                     {req, Req, Timeout}
             end,
      gen_server:call(Pid, Call, CallTimeout).
  
  encode_2i(Value) when is_integer(Value) ->
      list_to_binary(integer_to_list(Value));
  