anchor.diff:  handle_options(State=#state{options=Options}) ->
       handle_options(Options, State).
   %% @private
  -handle_options([], State) -> State;
  +handle_options([], State) -> 
  +    State;
   handle_options([{returnbody, true}|T], State=#state{w=W}) ->
  -    handle_options(T, State#state{returnbody=true,dw=W});
  -handle_options([{returnbody, V}|T], State) ->
  -    handle_options(T, State#state{returnbody=V});
  +    handle_options(T, State#state{returnbody=true,dw=W, reply_arity=2});
  +handle_options([{returnbody, false}|T], State) ->
  +    case has_postcommit_hooks(element(1,State#state.bkey)) of
  +        true ->
  +            handle_options(T, State#state{returnbody=true});
  +        false ->
  +            handle_options(T, State#state{returnbody=false})
  +    end;
   handle_options([{_,_}|T], State) -> handle_options(T, State).
   
   %% @private
   initialize(timeout, StateData0=#state{robj=RObj0, req_id=ReqId, client=Client,
  -                                      timeout=Timeout, ring=Ring, 
  +                                      timeout=Timeout, ring=Ring, bkey={Bucket,Key},
                                         rclient=RClient, options=Options}) ->
       case invoke_hook(precommit, RClient, update_metadata(RObj0)) of
           fail ->
  
positive.code:     end;
  waiting_vnode_dw({dw, Idx, ResObj, ReqId},
                   StateData=#state{dw=DW, client=Client, replied_dw=Replied0, 
                                    allowmult=AllowMult,
                                    rclient=RClient, resobjs=ResObjs0}) ->
      Replied = [Idx|Replied0],
      ResObjs = [ResObj|ResObjs0],
      case length(Replied) >= DW of
          true ->
              ReplyObj = merge_robjs(ResObjs, AllowMult),
              Client ! {ReqId, {ok, ReplyObj}},
              invoke_hook(postcommit, RClient, ReplyObj),
              update_stats(StateData),
              {stop,normal,StateData};
  
negative.code:     gen_fsm:start(?MODULE, [ReqId,RObj,W,DW,Timeout,From,Options], []).
  
  %% @private
  init([ReqId,RObj0,W,DW,Timeout,Client,Options0]) ->
      Options = case Options0 of [] -> ?DEFAULT_OPTS; _ -> Options0 end,
      {ok,Ring} = riak_core_ring_manager:get_my_ring(),
      BucketProps = riak_core_bucket:get_bucket(riak_object:bucket(RObj0), Ring),
      AllowMult = proplists:get_value(allow_mult,BucketProps),
      {ok, RClient} = riak:local_client(),
      Bucket = riak_object:bucket(RObj0),
      Key = riak_object:key(RObj0),    
      StateData0 = #state{robj=RObj0, client=Client, w=W, dw=DW, bkey={Bucket, Key},
                          req_id=ReqId, timeout=Timeout, ring=Ring,
                          rclient=RClient, options=proplists:unfold(Options),
                          resobjs=[], allowmult=AllowMult, reply_arity=1},
      StateData = handle_options(StateData0),
      {ok,initialize,StateData,0}.
  
  