anchor.diff:      %% Known may have shrunk since the lock was taken (due to nodedowns).
       Known = S0#state.known,
       Synced = S0#state.synced,
  -    NewNodes = [Node | HisKnown],
  -    sync_others(HisKnown),
  +    NewNodes = make_node_vsn_list([Node | HisKnown], S0),
  +    HisKnownNodes = node_list(HisKnown),
  +    sync_others(HisKnownNodes),
       ExtraInfo = [{vsn,get({prot_vsn, Node})}, {lock, get({lock_id, Node})}],
       S = do_ops(Ops, node(), Names_ext, ExtraInfo, S0),
       %% I am synced with Node, but not with HisKnown yet
  
positive.code:     S = trace_message(S0, {exit_resolver, Node}, [MyTag]),
      case get({sync_tag_my, Node}) of
  	MyTag ->
              Known = S#state.known,
  	    gen_server:cast({global_name_server, Node},
  			    {resolved, node(), Resolved, Known,
  			     Known,get_names_ext(),get({sync_tag_his,Node})}),
              case get({save_ops, Node}) of
                  {resolved, HisKnown, Names_ext, HisResolved} ->
                      put({save_ops, Node}, Ops),
  
negative.code: 
  handle_nodedown(Node, S) ->
      %% DOWN signals from monitors have removed locks and registered names.
      #state{synced = Syncs} = S,
      NewS = cancel_locker(Node, S, get({sync_tag_my, Node})),
      NewS#state.the_locker ! {remove_from_known, Node},
      reset_node_state(Node),
      NewS#state{known = maps:remove(Node, S#state.known),
                 synced = lists:delete(Node, Syncs)}.
  
  node_vsn(Node, #state{known = Known}) ->
      case maps:find(Node, Known) of
          {ok, Ver} ->
              Ver;
          error ->
              case get({pending_known, Node}) of
                  undefined -> -1;
                  Ver when is_integer(Ver) -> Ver
              end
      end.
  
  node_list(NList) ->
      lists:map(fun (N) when is_atom(N) ->
                        N;
                    ({N, _V}) when is_atom(N) ->
                        N
                end, NList).
      
  
  make_node_vsn_list(NList, #state{} = S) ->
      lists:map(fun ({N, -1}) when is_atom(N) ->
                        {N, node_vsn(N, S)};
                    (N) when is_atom(N) ->
                        {N, node_vsn(N, S)};
                    ({N, V} = NV) when is_atom(N),
                                       is_integer(V) ->
                        NV
                end, NList).
                            
  
  mk_known_list(Vsn, #state{known = Known}) when Vsn < 7 ->
      lists:map(fun ({N, _V}) -> N end, maps:to_list(Known));
  mk_known_list(_Vsn, #state{known = Known}) ->
      maps:to_list(Known).
  
  add_to_known(AddKnown, #state{known = Known} = S) ->
      Fun = fun (N, Acc) when N == node() ->
                    Acc;
                ({N, _V}, Acc) when N == node() ->
                    Acc;
                (N, {A, K} = Acc) when is_atom(N) ->
                    case maps:is_key(N, K) of
                        true -> Acc;
                        false -> {[N|A], maps:put(N, -1, K)}
                    end;
                ({N, V}, {A, K} = Acc) ->
                    case maps:find(N, K) of
                        error ->
                            {[N|A], maps:put(N, V, K)};
                        {ok, NV} when NV >= 0 ->
                            Acc;
                        {ok, _UnknownVsn} ->
                            %% Update version, but don't count
                            %% it as an added node...
                            {A, maps:put(N, V, K)}
                    end
            end,
  
      {Added, NewKnown} = lists:foldl(Fun, {[], Known}, AddKnown),
      {Added, S#state{known = NewKnown}}.
  
  get_names() ->
      ets:select(global_names, 
  