anchor.diff:      ?TRACE("fd_hbs crashed ~p~n", [WatchedPid]),
       report_crashed_remote_pid(State, WatchedPid, Reason, warn);
   
  -on({report_crashed, WatchedPid, Reason}, State) ->
  -    ?TRACE("fd_hbs report crashed ~p~n", [WatchedPid]),
  -    report_crashed_remote_pid(State, WatchedPid, Reason, nowarn);
  +on({report_crashed, WatchedPids, Reason}, State) ->
  +    ?TRACE("fd_hbs report crashed ~p~n", [WatchedPids]),
  +    lists:foldl(fun(WatchedPid, StateX) ->
  +                        report_crashed_remote_pid(StateX, WatchedPid, Reason,
  +                                                  nowarn)
  +                end, State, WatchedPids);
   
   on({report_crash, LocalPids, Reason}, State) when is_list(LocalPids) ->
       ?TRACE("fd_hbs crash reported ~.0p, ~.0p with reason ~.0p~n",
              [WatchedPid, pid_groups:group_and_name_of(WatchedPid), Reason]),
       % similar to 'DOWN' report below
  -    lists:foldl(
  -      fun(LocalPid, StateX) ->
  -              GlobalPid = comm:make_global(LocalPid),
  -              case state_has_monitor(StateX, GlobalPid) of
  -                  true ->
  -                      %% send crash report to remote end.
  -                      comm:send(state_get_rem_hbs(State),
  -                                {report_crashed, GlobalPid, Reason},
  -                                ?SEND_OPTIONS),
  -                      %% delete WatchedPid and MonRef locally
  -                      state_del_monitor(State, GlobalPid);
  -                  false -> StateX
  -              end
  -      end, State, LocalPids);
  +    {WatchedPids, State1} =
  +        lists:foldl(
  +          fun(LocalPid, {WatchedPidsX, StateX}) ->
  +                  GlobalPid = comm:make_global(LocalPid),
  +                  %% delete WatchedPid and MonRef locally (if existing)
  +                  case state_del_monitor(StateX, GlobalPid) of
  +                      {true, StateX1} -> {[GlobalPid | WatchedPidsX], StateX1};
  +                      {false, StateX1} -> {WatchedPidsX, StateX1}
  +                  end
  +          end, {[], State}, LocalPids),
  +    %% send crash report to remote end.
  +    comm:send(state_get_rem_hbs(State),
  +              {report_crashed, WatchedPids, Reason},
  +              ?SEND_OPTIONS),
  +    State1;
   
   on({'DOWN', _Monref, process, WatchedPid, _}, State) ->
       ?TRACE("fd_hbs DOWN reported ~.0p, ~.0p~n",
  
positive.code:                  State
      end.
  
  -spec state_has_monitor(state(), comm:mypid()) -> boolean().
  state_has_monitor(State, WatchedPid) ->
      Table = state_get_monitor_tab(State),
      pdb:get({'$monitor', WatchedPid}, Table) =/= undefined.
  
  -spec state_add_monitor(state(), comm:mypid()) -> state().
  state_add_monitor(State, WatchedPid) ->
      Table = state_get_monitor_tab(State),
  
negative.code:     pdb:set({{'$monitor', WatchedPid}, MonRef}, Table),
      State.
  
  -spec state_del_monitor(state(), comm:mypid()) -> {Found::boolean(), state()}.
  state_del_monitor(State, WatchedPid) ->
      Table = state_get_monitor_tab(State),
      CountKey = {'$monitor_count', WatchedPid},
      Found = case pdb:take(CountKey, Table) of
                  undefined ->
                      false;
                  {CountKey, 1} ->
                      MonKey = {'$monitor', WatchedPid},
                      {MonKey, MonRef} = pdb:take(MonKey, Table),
                      erlang:demonitor(MonRef),
                      true;
                  {CountKey, X} when is_integer(X) andalso X > 1 ->
                      pdb:set({CountKey, X - 1}, Table),
                      true
              end,
      {Found, State}.
  
  -spec rempid_new(comm:mypid()) -> rempid().
  rempid_new(Pid) ->
  