anchor.diff:      gen_server:call(?MODULE, {get, IdOrPid}).
   
   subscribe_dead(Subscriber, DeadPid) ->
  -    gen_server:cast(?MODULE, {subscribe_dead, Subscriber, Pid}).
  +    gen_server:cast(?MODULE, {subscribe_dead, Subscriber, DeadPid}).
   
   unsubscribe_dead(Subscriber, DeadPid) ->
  -    gen_server:cast(?MODULE, {unsubscribe_dead, Subscriber, Pid}).
  +    gen_server:cast(?MODULE, {unsubscribe_dead, Subscriber, DeadPid}).
   
   replace_dead(OldPid, NewPid) ->
       gen_server:cast(?MODULE, {replace_pid, OldPid, NewPid}).
  
positive.code:         fun() ->
              MatchHead = #object{pid=Pid, _='_'},
              Result = '$_',
              mnesia:select(object, [{MathHead, [], [Result]}])
          end,
      case mnesia:transaction(Fun) of
          {atomic, []} ->
              {reply, undefined, State};
          {atomic, [Object = #object{properties = Props} | _]} ->
              Props2 = ids2pids(Props),
              {reply, Object#object{properties = Props}, State}
      end.
  
  update_object(Pid, {icon, Icon})
      Fun = fun(Object) ->
                Object#object{icon = Icon}
            end,
      update_object(Pid, Fun);
  update_object(Pid, {id, Id})
      Fun = fun(Object) ->
                Object#object{id = Id}
            end,
      update_object(Pid, Fun),
  update_object(Pid, UpdateFun) when is_function(UpdateFun) ->
      Fun =
          fun() ->
              MatchHead = #object{pid=Pid, _='_'},
              Result = {'$_'},
              case mnesia:select(object, [{MathHead, [], [Result]}]) of
                  undefined
          end,
      case mnesia:transaction(Fun) of
          {atomic, []} ->
              {reply, undefined, State};
          {atomic, [Object | _]} ->
              {reply, Object, State}
      end.
  
  subscribe_dead(Subscriber, Pid) ->
      fun() ->
          case mnesia:read(replacement_pid, Pid) of
              [#replacement_pid{new_pid = NewPid} | _] ->
                  Subsriber ! {replace_pid, Pid, NewPid};
              [] ->
                  mnesia:write(#dead_pid_subscription{subscriber = self(),
                                                      dead_pid = Pid})
                  OneMinute = 60 * 1000,
                  Message = {delete, #dead_pid_subscription{subscriber = self(),
                                                            dead_pid = Pid}},
                  erlang:send_after(OneMinute, self(), Message).
          end
      end,
      mnesia:transaction(Fun),
  
  unsubscribe_dead(Subscriber, OldPid) ->
      OldRecord = #broken_link{object_pid = self(),
                               dead_pid = OldPid},
      fun() ->
          mnesia:delete(OldRecord)
      end,
      {atomic, ok} = mnesia:transaction(Fun).
  
  replace_dead(OldPid, NewPid) ->
      Fun =
          fun() ->
              Object = #dead_pid_subscription{dead_pid = OldPid, _ = '_'},
              Subs = mnesia:match_object(Object)
              [Sub ! {replace_pid, OldPid, NewPid}
               || #dead_pid_subscription{subscriber = Sub} <- Subs].
  
              mnesia:write(#replacement_pid{old_pid = OldPid,
                                            new_pid = NewPid})
  
negative.code: handle_call(_Request, _From, State) ->
      {reply, ignored, State}.
  
  handle_cast({put, Props}, State) when is_list(Props) ->
      Props2 = [pid2id(Prop) || Prop <- Props],
      Pid = proplists:get_value(pid, Props),
      Id = proplists:get_value(id, Props),
  