anchor.diff:                object = RObj1,
                 req_id = ReqId,
                 start_time = RealStartTime,
  -              options = Options},
  +              options = VnodeOptions},
               N = proplists:get_value(n_val,BucketProps),
               Preflist = riak_core_ring:preflist(DocIdx, Ring),
               %% TODO: Replace this with call to riak_kv_vnode:put/6
  
positive.code:     end;
  waiting_vnode_dw({dw, Idx, ResObj, ReqId},
                   StateData=#state{dw=DW, client=Client, replied_dw=Replied0,
                                    allowmult=AllowMult, reply_arity=ReplyArity,
                                    rclient=RClient, resobjs=ResObjs0}) ->
      Replied = [Idx|Replied0],
      ResObjs = [ResObj|ResObjs0],
      case length(Replied) >= DW of
          true ->
              ReplyObj = merge_robjs(ResObjs, AllowMult),
              Reply = case ReplyArity of 1 -> ok; 2 -> {ok, ReplyObj} end,
              Client ! {ReqId, Reply},
              invoke_hook(postcommit, RClient, ReplyObj),
              update_stats(StateData),
  
negative.code:                                 client=Client, w=W, dw=DW, bkey={Bucket, Key},
                                  req_id=ReqId, timeout=Timeout, ring=Ring,
                                  rclient=RClient, 
                                  vnode_options=[],
                                  resobjs=[], allowmult=AllowMult},
              StateData = handle_options(Options, StateData0),
              {ok,initialize,StateData,0}
      end.
  
  %%
  %% Given an expanded proplist of options, take the first entry for any given key
  %% and ignore the rest
  %%
  %% @private
  flatten_options([], Opts) ->
      Opts;
  flatten_options([{Key, Value} | Rest], Opts) ->
      case lists:keymember(Key, 1, Opts) of
          true ->
              flatten_options(Rest, Opts);
          false ->
              flatten_options(Rest, [{Key, Value} | Opts])
      end.
  
  %% @private
  handle_options([], State) ->
      State;
  handle_options([{returnbody, true}|T], State) ->
      VnodeOpts = [{returnbody, true} | State#state.vnode_options],
      handle_options(T, State#state{vnode_options=VnodeOpts,
                                    returnbody=true});
  handle_options([{returnbody, false}|T], State) ->
      case has_postcommit_hooks(element(1,State#state.bkey)) of
          true ->
              %% We have post-commit hooks, we'll need to get the body back
              %% from the vnode, even though we don't plan to return that to the
              %% original caller
              VnodeOpts = [{returnbody, true} | State#state.vnode_options],
              handle_options(T, State#state{vnode_options=VnodeOpts,
                                            returnbody=false});
          false ->
              handle_options(T, State#state{returnbody=false})
      end;
  