anchor.diff:      AddrId = Object#?OBJECT.addr_id,
       Key    = Object#?OBJECT.key,
       ReqId  = Object#?OBJECT.req_id,
  +    NumOfNodes = erlang:length(Nodes),
       From = self(),
   
  -    ok = replicate_1(Nodes, From, AddrId, Key, Object, ReqId),
  +    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),
   
  -    loop(Quorum, From, [], #state{method       = Method,
  -                                  addr_id      = AddrId,
  -                                  key          = Key,
  -                                  num_of_nodes = erlang:length(Nodes),
  -                                  callback     = Callback,
  -                                  errors       = []}).
  +    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) ->
  
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:           key          :: binary(),
            num_of_nodes :: pos_integer(),
            callback     :: function(),
            errors = []  :: list(),
            is_reply = false ::boolean()
           }).
  
  
  