anchor.diff:      ?TRACEPONG("Pinger pong for ~p~n", [_Subscriber]),
       Now = erlang:now(),
       LastPong = state_get_last_pong(State),
  +%    CrashedAfter = state_get_crashed_after(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));
  +    NewCrashedAfter = time_plus(Now, 3*Delay),
  +%    state_set_crashed_after(S1, erlang:max(NewCrashedAfter, CrashedAfter));
  +    state_set_crashed_after(S1, NewCrashedAfter);
   
   on({periodic_alive_check}, State) ->
       ?TRACEPONG("Pinger periodic_alive_check~n", []),
  
positive.code:     comm:send(RemoteFDPid,
                {subscribe_heartbeats, comm:this(), RemotePid}),
  
      comm:send_local(self(), {periodic_alive_check}),
      Now = erlang:now(),
      state_new(_RemoteHBS = RemoteFDPid, _RemotePids = [{RemotePid, 1}],
                _LastPong = {0,0,0},
  
negative.code: 
  %% @doc Reports the crash to local subscribers.
  %% @private
  -spec report_crash(state()) -> kill.
  report_crash(State) ->
      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(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.
  