anchor.diff:          true ->
               {next_state,waiting_vnode_w,NewStateData};
           false ->
  -            update_stats(StateData),
  -            Client ! {ReqId, {error,too_many_fails}},
  +            update_stats(NewStateData),
  +            client_reply({error,too_many_fails}, NewStateData),
               {stop,normal,NewStateData}
       end;
  -waiting_vnode_w(timeout, StateData=#state{client=Client,req_id=ReqId}) ->
  +waiting_vnode_w(timeout, StateData) ->
       update_stats(StateData),
  -    Client ! {ReqId, {error,timeout}},
  +    client_reply({error,timeout}, StateData),
       {stop,normal,StateData}.
   
   waiting_vnode_dw({w, _Idx, ReqId},
             StateData=#state{req_id=ReqId}) ->
       {next_state,waiting_vnode_dw,StateData};
   waiting_vnode_dw({dw, Idx, ReqId},
  -                 StateData=#state{dw=DW, client=Client, replied_dw=Replied0}) ->
  +                 StateData=#state{dw=DW, req_id=ReqId, replied_dw=Replied0}) ->
       Replied = [Idx|Replied0],
       case length(Replied) >= DW of
           true ->
  -            Client ! {ReqId, ok},
  +            client_reply(ok, StateData),
               update_stats(StateData),
               {stop,normal,StateData};
           false ->
  
positive.code:             {next_state,execute,StateData,0}
      end.
  
  execute(timeout, StateData0=#state{robj=RObj0, req_id=ReqId, client=Client,
                                        update_last_modified=UpdateLastMod,
                                        timeout=Timeout, ring=Ring, bkey={Bucket,Key}=BKey,
                                        rclient=RClient, vnode_options=VnodeOptions}) ->
      case invoke_hook(precommit, RClient, update_last_modified(UpdateLastMod, RObj0)) of
          fail ->
              Client ! {ReqId, {error, precommit_fail}},
              {stop, normal, StateData0};
          {fail, Reason} ->
              Client ! {ReqId, {error, {precommit_fail, Reason}}},
              {stop, normal, StateData0};
          RObj1 ->
              StartNow = now(),
  
negative.code:                         true  -> {ok, ReplyObj};
                          false -> ok
                      end,
              client_reply(Reply, StateData),
              invoke_hook(postcommit, RClient, ReplyObj),
              update_stats(StateData),
              {stop,normal,StateData};
  