anchor.diff:  restarting(current_state, _From, State) ->
       {reply, restarting, restarting, State}.
   
  +%%
  +%% These events are handled the same everywhere
  +%%
   handle_event({start_watching, Who}, StateName, #state{observers=Observers}=State) ->
       State1 = case lists:member(Who, Observers) of
           false ->
  
positive.code:     erlang:cancel_timer(TRef),
      TRef1 = erlang:send_after(Interval, self(), down),
      State#state{tref=TRef1}.
  
negative.code:         Pid ->
              gen_fsm:sync_send_event(Pid, current_state, infinity)
      end.
  
  
  -spec set_logging(node_name(), logging_level()) ->  gproc_error().
  set_logging(Name, verbose) ->
      set_logging(Name, verbose, ok);
  set_logging(Name, normal) ->
      set_logging(Name, normal, ok).
  
  set_logging(Name, Level, ok) ->
      case catch gproc:lookup_pid({n,l,Name}) of
          {'EXIT', _} ->
              ?NO_NODE;
          Pid ->
              gen_fsm:send_all_state_event(Pid, {logging, Level})
      end.
  
  -spec start_watching(node_name()) -> gproc_error().
  start_watching(Name) ->
      watching(start_watching, Name).
  
  -spec stop_watching(node_name()) -> gproc_error().
  stop_watching(Name) ->
      watching(stop_watching, Name).
  
  -spec watching('start_watching' | 'stop_watching', node_name()) -> gproc_error().
  watching(Action, Name) ->
      case catch gproc:lookup_pid({n,l,Name}) of
          {'EXIT', _} ->
              ?NO_NODE;
          Pid ->
              gen_fsm:send_all_state_event(Pid, {Action, self()})
      end.
  
  
  init([Name, HeartbeatInterval, DeadIntervalCount]) ->
      {ok, initializing, #state{dead_interval=HeartbeatInterval * DeadIntervalCount,
  