anchor.diff:      report_inconsistency(Replies, Context, Status);
   report_inconsistency([], _Context, Status) ->
       Status.
  +
  +remote_node_status(Node, Status, State) ->
  +    {ok, Nodes} = mnesia_schema:read_nodes(),
  +    case lists:member(Node, Nodes) of
  +	true ->
  +	    update_node_status({Node, Status}, State);
  +	_ ->
  +	    State
  +    end.
  +
  +update_node_status({Node, down}, State = #state{remote_node_status = RNodeS}) ->
  +    RNodeS2 = lists:ukeymerge(1, [{Node, down}], RNodeS),
  +    State#state{remote_node_status = RNodeS2};
  +update_node_status({Node, up}, State = #state{remote_node_status = RNodeS}) ->
  +    case lists:keyfind(Node, 1, RNodeS) of
  +	{Node, down} ->
  +	    RNodeS2 = lists:ukeymerge(1, [{Node, up}], RNodeS),
  +	    State#state{remote_node_status = RNodeS2};
  +	_ ->
  +	    State
  +    end.
  +
  +check_raise_conditon_nodeup(Node, State = #state{remote_node_status = RNodeS}) ->
  +    case lists:keyfind(Node, 1, RNodeS) of
  +	{Node, up} ->
  +	    self() ! {check_nodeup, Node};
  +	_ ->
  +	    ignore
  +    end,
  +    State#state{remote_node_status = lists:keydelete(Node, 1, RNodeS)}.
  +
  +check_mnesia_down(Node, State = #state{remote_node_status = RNodeS}) ->
  +    %% Check if the network has been partitioned
  +    %% due to communication failure.
  +
  +    HasDown   = mnesia_recover:has_mnesia_down(Node),
  +    ImRunning = mnesia_lib:is_running(),
  +    if
  +	%% If I'm not running the test will be made later.
  +	HasDown == true, ImRunning == yes ->
  +	    spawn_link(?MODULE, detect_partitioned_network, [self(), Node]),
  +	    State#state{remote_node_status = lists:keydelete(Node, 1, RNodeS)};
  +	true ->
  +	    State
  +    end.
  
positive.code:     GoingDown = lists:delete(Node, State#state.going_down),
      State2 = State#state{going_down = GoingDown},
      Pending = State#state.pending_negotiators,
      case lists:keysearch(Node, 1, Pending) of
  	{value, {Node, Mon, ReplyTo, Reply}} ->
  	    %% Late reply to remote monitor
  	    link(Mon),  %% link to remote Monitor
  	    gen_server:reply(ReplyTo, Reply),
  	    P2 = lists:keydelete(Node, 1,Pending),
  	    State3 = State2#state{pending_negotiators = P2},
  	    process_q(State3);
  	false ->
  	    %% No pending remote monitors
  	    process_q(State2)
      end;
  
  handle_cast({disconnect, Node}, State) ->
  
negative.code:     gen_server:reply(From, Res),
      process_q(State#state{connecting = undefined});
  
  handle_info({check_nodeup, Node}, State) ->
      State2 = check_mnesia_down(Node, State),
      {noreply, State2};
  
  handle_info({nodeup, Node}, State) ->
      State2 = remote_node_status(Node, up, State),
      State3 = check_mnesia_down(Node, State2),
      {noreply, State3};
  
  handle_info({nodedown, Node}, State) ->
      State2 = remote_node_status(Node, down, State),
      {noreply, State2};
  
  handle_info({disk_log, _Node, Log, Info}, State) ->
      case Info of
  