anchor.diff:                      _ ->
                           NewEntry =
                               case rempid_refcount(Entry) of
  -                                0 -> %% retrigger delayed del watching
  -                                    NewTime = os:timestamp(),
  -                                    msg_delay:send_local(
  -                                      1, self(),
  -                                      {check_delayed_del_watching_of,
  -                                       WatchedPid, NewTime}),
  -                                    rempid_set_last_modified(Entry, NewTime);
  -                                _ ->
  -                                    rempid_set_pending_demonitor(Entry, false)
  +                                0 -> trigger_delayed_del_watching(Entry);
  +                                _ -> rempid_set_pending_demonitor(Entry, false)
                               end,
                           lists:keyreplace(WatchedPid, 1, RemPids, NewEntry)
                   end,
  
positive.code:                 case {rempid_refcount(TmpEntry),
                        rempid_get_pending_demonitor(TmpEntry)} of
                      {0, false} -> %% dec to 0 and triggger new delayed message
                          Time = os:timestamp(),
                          %% delayed demonitoring: remember current time
                          %% self-inform on pending demonitoring with current
                          %% time.
                          %% actually delete if timestamp of the entry is
                          %% still the same after delay
                          msg_delay:send_local(
                            1, self(),
                            {check_delayed_del_watching_of, WatchedPid, Time}),
                          T2 = rempid_set_last_modified(TmpEntry, Time),
                          rempid_set_pending_demonitor(T2, true);
                      {0, true} -> %% dec to 0 and no new delayed message needed
                          TmpEntry;
                      _ -> TmpEntry
  
negative.code: 
  -spec delayfactor() -> pos_integer().
  delayfactor() -> 4.
  
  -spec trigger_delayed_del_watching(rempid()) -> rempid().
  trigger_delayed_del_watching(RemPidEntry) ->
      %% delayed demonitoring: remember current time self-inform on
      %% pending demonitoring with current time.
      %% actually delete if timestamp of the entry is still the same
      %% after delay
      WatchedPid = rempid_get_rempid(RemPidEntry),
      Time = os:timestamp(),
      msg_delay:send_local(1, self(),
                           {check_delayed_del_watching_of, WatchedPid, Time}),
      E1 = rempid_set_last_modified(RemPidEntry, Time),
      rempid_set_pending_demonitor(E1, true).
  
  -spec state_new(comm:mypid(), [rempid()],
                  util:time(), util:time(), atom()) -> state().
  