anchor.diff:              ets:insert(Scope, {Group, Pids, []})
       end.
   
  -join_remote_map(Group, Pid, RemoteGroups) when is_pid(Pid) ->
  +join_remote(Group, Pid, RemoteGroups) when is_pid(Pid) ->
       maps:update_with(Group, fun (List) -> [Pid | List] end, [Pid], RemoteGroups);
  -join_remote_map(Group, Pids, RemoteGroups) ->
  +join_remote(Group, Pids, RemoteGroups) ->
       maps:update_with(Group, fun (List) -> Pids ++ List end, Pids, RemoteGroups).
   
  -leave_monitors(Pid, Group, Monitors) when is_pid(Pid) ->
  -    case maps:find(Pid, Monitors) of
  +leave_local(Pid, Group, Local) when is_pid(Pid) ->
  +    case maps:find(Pid, Local) of
           {ok, {MRef, [Group]}} ->
               erlang:demonitor(MRef),
  -            maps:remove(Pid, Monitors);
  +            maps:remove(Pid, Local);
           {ok, {MRef, Groups}} ->
               case lists:member(Group, Groups) of
                   true ->
  -                    maps:put(Pid, {MRef, lists:delete(Group, Groups)}, Monitors);
  +                    maps:put(Pid, {MRef, lists:delete(Group, Groups)}, Local);
                   false ->
  -                    Monitors
  +                    Local
               end;
           _ ->
  -            Monitors
  -    end;
  -leave_monitors([], _Group, Monitors) ->
  -    Monitors;
  -leave_monitors([Pid | Tail], Group, Monitors) ->
  -    leave_monitors(Tail, Group, leave_monitors(Pid, Group, Monitors)).
  -
  -leave_local_group(Scope, Group, Pid) when is_pid(Pid) ->
  +            Local
  +    end;
  +leave_local([], _Group, Local) ->
  +    Local;
  +leave_local([Pid | Tail], Group, Local) ->
  +    leave_local(Tail, Group, leave_local(Pid, Group, Local)).
  +
  +leave_local_update_ets(Scope, Group, Pid) when is_pid(Pid) ->
       case ets:lookup(Scope, Group) of
           [{Group, [Pid], [Pid]}] ->
               ets:delete(Scope, Group);
  
positive.code:             end
          end, RemoteMap, Groups).
  
  all_local_pids(Monitors) ->
      maps:to_list(maps:fold(
          fun(Pid, {_Ref, Groups}, Acc) ->
              lists:foldl(
                  fun(Group, Acc1) ->
                      Acc1#{Group => [Pid | maps:get(Group, Acc1, [])]}
                  end,
                  Acc,
                  Groups
              )
          end,
          #{},
          Monitors
      )).
  
  %% Works as gen_server:abcast(), but accepts a list of processes
  %%   instead of nodes list.
  
negative.code:                 true
          end ||
          Group <- Groups];
  leave_remote_update_ets(Scope, Pids, Groups) ->
      _ = [
          case ets:lookup(Scope, Group) of
              [{Group, All, Local}] ->
  