anchor.diff:            key          :: binary(),
             num_of_nodes :: pos_integer(),
             callback     :: function(),
  -          errors = []  :: list()
  +          errors = []  :: list(),
  +          is_reply = false ::boolean()
            }).
   
   
  
positive.code: 
  %% @doc Waiting for messages (replication)
  %% @private
  loop(0,_From, ResL, #state{method = Method,
                             callback = Callback}) ->
      Callback({ok, Method, hd(ResL)});
  
  loop(W,_From,_ResL, #state{num_of_nodes = NumOfNodes,
                             callback = Callback,
                             errors = Errors}) when (NumOfNodes - W) < length(Errors) ->
      Callback({error, Errors});
  
  loop(W, From, ResL, #state{addr_id = AddrId,
                             key = Key,
                             callback = Callback,
                             errors = Errors} = State) ->
      receive
          {ok, Checksum} ->
              loop(W-1, From, [Checksum|ResL], State);
          {error, {Node, Cause}} ->
              ok = enqueue(?ERR_TYPE_REPLICATE_DATA, AddrId, Key),
              loop(W, From, ResL, State#state{errors = [{Node, Cause}|Errors]})
      after
          ?DEF_REQ_TIMEOUT ->
              case (W >= 0) of
                  true ->
                      Callback({error, timeout});
                  false ->
                      void
              end
  
negative.code:     AddrId = Object#?OBJECT.addr_id,
      Key    = Object#?OBJECT.key,
      ReqId  = Object#?OBJECT.req_id,
      NumOfNodes = erlang:length(Nodes),
      From = self(),
  
      Pid = spawn(fun() ->
                          loop(NumOfNodes, Quorum, [],
                               From, #state{method       = Method,
                                            addr_id      = AddrId,
                                            key          = Key,
                                            num_of_nodes = NumOfNodes,
                                            callback     = Callback,
                                            errors       = [],
                                            is_reply     = false
                                           })
                  end),
  
      ok = replicate_1(Nodes, Pid, AddrId, Key, Object, ReqId),
      receive
          Reply ->
              Callback(Reply)
      after
          ?DEF_REQ_TIMEOUT ->
              Callback({error, timeout})
      end.
  
  %% @private
  replicate_1([],_From,_AddrId,_Key,_Object,_ReqId) ->
  