anchor.diff:  
   %% @doc Reports the crash to local subscribers.
   %% @private
  --spec report_crash(state()) -> ok.
  +-spec report_crash(state()) -> kill.
   report_crash(State) ->
  -    log:log(warn, "[ FD ~p ] reports ~.0p as crashed",
  +    log:log(warn, "###################[ FD ~p ] reports ~.0p as crashed",
               [comm:this(), state_get_rem_pids(State)]),
       FD = pid_groups:find_a(fd),
       comm:send_local(FD, {hbs_finished, state_get_rem_hbs(State)}),
  -    erlang:unlink(pid_groups:find_a(fd)),
  -    lists:foldl(fun(X, S) -> on({crashed, X}, S) end,
  -                State, [RemPid || {RemPid, _} <- state_get_rem_pids(State)]),
  +    erlang:unlink(FD),
  +    _ = try
  +            lists:foldl(fun(X, S) -> on({crashed, X}, S) end,
  +                        State, [RemPid || {RemPid, _} <- state_get_rem_pids(State)])
  +        catch _:_ -> ignore_exception
  +        end,
       kill.
   
   %% @doc The interval between two failure detection runs.
  
positive.code:     ?TRACEPONG("Pinger pong for ~p~n", [_Subscriber]),
      Now = erlang:now(),
      LastPong = state_get_last_pong(State),
      Delay = abs(timer:now_diff(Now, LastPong)),
      S1 = state_set_last_pong(State, Now),
      state_set_crashed_after(S1, time_plus(Now, 3*Delay));
  
  on({periodic_alive_check}, State) ->
      ?TRACEPONG("Pinger periodic_alive_check~n", []),
  
negative.code:     comm:send(RemoteFDPid,
                {subscribe_heartbeats, comm:this(), RemotePid}),
  
      %% no periodic alive check inside same vm (to succeed unittests)
      case comm:is_local(RemotePid) of
          false -> comm:send_local(self(), {periodic_alive_check});
          true -> ok
      end,
      Now = erlang:now(),
      state_new(_RemoteHBS = RemoteFDPid, _RemotePids = [{RemotePid, 1}],
                _LastPong = {0,0,0},
  