anchor.diff:      mc_downstream:send(Addr, Out, Cmd, CmdArgs,
                          ResponseFilter, ResponseModule);
   
  -send([Addr], Out, Cmd, CmdArgs,
  -     ResponseFilter, ResponseModule, _) ->
  -    mc_downstream:send(Addr, Out, Cmd, CmdArgs,
  -                       ResponseFilter, ResponseModule).
  -
  -xsend(Addrs, Out, Cmd, CmdArgs,
  +send(Addrs, Out, Cmd, CmdArgs,
        ResponseFilter, ResponseModule, Policy) ->
       gen_server:call(?MODULE,
                       {replicate,
  
positive.code:           {0, []}, Addrs),
      Replicator =
          create_replicator(Id, Request, NotifyPid, undefined,
                            SentOk, Monitors, SuccessMin),
      Replicators2 =
          case update_replicator(Replicator) of
              {ok, R} -> dict:store(Id, R, Replicators);
              _       -> dict:erase(Id, Replicators)
          end,
      {reply, {ok, []}, RMgr#rmgr{curr = Replicators2}}.
  
  handle_cast({response, Id, Addr, RV},
               #rmgr{curr = Replicators} = RMgr) ->
      % Invoked when a downstream sends some more partial response.
      case dict:find(Id, Replicators) of
          {ok, Rep} ->
              Responses2 = [{Addr, RV} | Rep#replicator.responses],
              Replicators2 =
                  dict:store(Id, Rep#replicator{responses = Responses2},
                             Replicators),
              {noreply, RMgr#rmgr{curr = Replicators2}};
          error ->
  
negative.code:             #rmgr{curr = Replicators} = RMgr) ->
      % Invoked when a downstream provides a final notification result.
      case dict:find(Id, Replicators) of
          {ok, #replicator{responses = Responses,
                           received_ok = ROk,
                           received_err = RErr} = Replicator} ->
              {ROk2, RErr2} = case RV of
                                  {ok, _}    -> {ROk + 1, RErr};
                                  {ok, _, _} -> {ROk + 1, RErr};
                                  _          -> {ROk, RErr + 1}
                              end,
              Replicator2 = Replicator#replicator{
                              responses = [{Addr, RV} | Responses],
                              received_ok = ROk2,
                              received_err = RErr2
                            },
              Replicators2 =
                  case update_replicator(Replicator2) of
                      {ok, R}    -> dict:store(Id, R, Replicators);
                      {done, _}  -> dict:erase(Id, Replicators);
                      {error, _} -> dict:erase(Id, Replicators)
                  end,
              {noreply, RMgr#rmgr{curr = Replicators2}};
          error ->
  