anchor.diff:      RequestValue#request{retry_count = RetryCount + 1}.
   
   response_store(RequestKey, ResponseInfo, Response,
  -               #state{sender_id = SenderId,
  -                      service = Service,
  -                      crdt = CRDT0} = State, Dispatcher) ->
  +               #state{crdt = CRDT0} = State, Dispatcher) ->
       ResponseData = {ResponseInfo, Response},
  -    CRDTN = cloudi_crdt:update(Dispatcher,
  -                               RequestKey,
  -                               ?MODULE,
  -                               response_store_crdt,
  -                               [RequestKey, ResponseData, Service, SenderId],
  -                               CRDT0),
  +    UpdateF = response_store_crdt,
  +    CRDTN = cloudi_crdt:update_id(Dispatcher,
  +                                  RequestKey,
  +                                  ?MODULE,
  +                                  UpdateF,
  +                                  ResponseData,
  +                                  UpdateF,
  +                                  CRDT0),
       State#state{crdt = CRDTN}.
   
  -response_store_crdt([RequestKey, ResponseData, Service, SenderId],
  -                    #request{name = Name,
  -                             pattern = Pattern,
  -                             timeout_last = TimeoutLast,
  -                             trans_id_last = TransIdLast,
  -                             pending = Pending,
  -                             sender_id = SenderIdRequest} = RequestValue) ->
  -    {ResponseInfo, Response} = ResponseData,
  -    ok = sender_only(fun() ->
  -        Service ! {response_return,
  -                   Name, Pattern, ResponseInfo, Response, Pending},
  -        ResponseTimeout = timeout_current(TimeoutLast, TransIdLast),
  -        erlang:send_after(ResponseTimeout, Service,
  -                          {response_timeout, RequestKey})
  -    end, SenderId, SenderIdRequest),
  +response_store_crdt(ResponseData, RequestValue) ->
       RequestValue#request{pending = [],
                            response = ResponseData}.
   
  
positive.code:                          cloudi_trans_id:microseconds(), Dispatcher),
      {noreply, State};
  cloudi_service_handle_info({response_timeout, RequestKey},
                             #state{sender_id = SenderId,
                                    service = Service,
                                    crdt = CRDT0} = State, Dispatcher) ->
      CRDTN = cloudi_crdt:update_clear(Dispatcher,
                                       RequestKey,
                                       ?MODULE,
                                       response_timeout_crdt,
                                       [RequestKey, Service, SenderId],
                                       CRDT0),
      {noreply, State#state{crdt = CRDTN}};
  cloudi_service_handle_info({retry, RequestKey},
                             #state{crdt = CRDT} = State, Dispatcher) ->
  
negative.code:         erlang:send_after(RetryDelay, Service, {retry, RequestKey})
      end, SenderId, SenderIdRetry),
      {noreply, State};
  cloudi_service_handle_info(#crdt_event{type = update,
                                         id = response_store_crdt,
                                         key = RequestKey,
                                         old = {value, RequestValueOld},
                                         new = {value, RequestValueNew}},
                             #state{sender_id = SenderId,
                                    service = Service} = State,
                             _Dispatcher) ->
      #request{name = Name,
               pattern = Pattern,
               pending = Pending,
               sender_id = SenderIdRequest,
               response = undefined} = RequestValueOld,
      #request{timeout_last = TimeoutLast,
               trans_id_last = TransIdLast,
               pending = [],
               response = {ResponseInfo, Response}} = RequestValueNew,
      ok = sender_only(fun() ->
          Service ! {response_return,
                     Name, Pattern, ResponseInfo, Response, Pending},
          ResponseTimeout = timeout_current(TimeoutLast, TransIdLast),
          erlang:send_after(ResponseTimeout, Service,
                            {response_timeout, RequestKey})
      end, SenderId, SenderIdRequest),
      {noreply, State};
  cloudi_service_handle_info(#crdt_event{type = update,
                                         id = response_timeout_crdt,
                                         key = RequestKey,
                                         new = {value, RequestValue}},
                             #state{sender_id = SenderId,
                                    service = Service} = State,
                             _Dispatcher) ->
      #request{timeout_last = TimeoutLast,
               trans_id_last = TransIdLast,
               sender_id = SenderIdRequest,
               response = {_, _}} = RequestValue,
      ok = sender_only(fun() ->
          ResponseTimeout = timeout_current(TimeoutLast, TransIdLast),
          erlang:send_after(ResponseTimeout, Service,
                            {response_timeout, RequestKey})
      end, SenderId, SenderIdRequest),
      {noreply, State};
  cloudi_service_handle_info(#crdt_event{id = {senders_crdt_merge,
                                               SenderIdMerge},
                                         key = senders,
  