anchor.diff:      ok = monitor_nodes(true,[{node_type,all}]),
       Reply = case lists:member(Node,nodes([connected])) of
                   true ->
  -                    io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
                       true;
                   _ ->
                       receive
                           {nodeup,Node,_} ->
  -                            io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
                               true
                       after connecttime() ->
  -                            io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
                               false
                       end
               end,
       ok = monitor_nodes(false,[{node_type,all}]),
  -    io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
       {Pid, Tag} = From,
  -    io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]),
  -    erlang:send(Pid, {Tag, Reply}),
  -    io:format("~p: passive_connect_monitor ~p\n", [self(), ?LINE]).
  +    erlang:send(Pid, {Tag, Reply}).
   
   
   %% If the net_kernel isn't running we ignore all requests to the
  
positive.code:                                 (hd(ConnLookup))#connection.state =:= up ->
                      ?connect_failure(Node,{barred_connection,
                                             ets:lookup(sys_dist, Node)}),
                      {reply, false, State};
                  _ ->
                      case setup(ConnLookup, Node,ConnId,Type,From,State) of
                          {ok, SetupPid} ->
                              Owners = [{SetupPid, Node} | State#state.conn_owners],
                              {noreply,State#state{conn_owners=Owners}};
                          _Error  ->
                              ?connect_failure(Node, {setup_call, failed, _Error}),
                              {reply, false, State}
                      end
              end
  
negative.code:     async_reply({reply, true, State}, From);
  handle_call({passive_cnct, Node}, From, State) ->
      verbose({passive_cnct, Node}, 1, State),
      R = do_auto_connect_1(Node, passive_cnct, From, State),
      return_call(R, From);
  
  %%
  