anchor.diff:  	    Return
       end.
       
  +remote_reply(Proc,Reply) when is_pid(Proc) ->
  +    Proc ! {?SERVER,Reply};
   remote_reply(MainNode,Reply) ->
       {?SERVER,MainNode} ! {?SERVER,Reply}.
   
  
positive.code: 
  %% Collect data from remote nodes - used for analyse or stop(Node)
  remote_collect(Module,Nodes,Stop) ->
      CollectorPid = spawn(fun() -> collector_proc(length(Nodes)) end),
      lists:foreach(
        fun(Node) -> 
  	      remote_call(Node,{remote,collect,Module,CollectorPid}),
  	      if Stop -> remote_call(Node,{remote,stop});
  		 true -> ok
  	      end
        end,
        Nodes).
  
  %% Process which receives chunks of data from remote nodes - either when
  %% analysing or when stopping cover on the remote nodes.
  collector_proc(0) ->
      ok;
  collector_proc(N) ->
      receive 
  	{chunk,Chunk} ->
  	    insert_in_collection_table(Chunk),
  	    collector_proc(N);
  	done ->
  	    collector_proc(N-1)
      end.
  
  insert_in_collection_table([{Key,Val}|Chunk]) ->
  
negative.code:             unregister(?SERVER),
  	    reply(From, ok);
  
  	{From, {{analyse, Analysis, Level}, Module}} ->
  	    S = try 
  		    Loaded = is_loaded(Module, State),
  		    analyse_info(Module,State#main_state.imported),
  		    C = case Loaded of
  			    {loaded, _File} ->
  				[{Module,Clauses}] = 
  				    ets:lookup(?COVER_TABLE,Module),
  				collect(Module,Clauses,State#main_state.nodes),
  				Clauses;
  			    _ ->
  				[{Module,Clauses}] = 
  				    ets:lookup(?COLLECTION_TABLE,Module),
  				Clauses
  			end,
  		    R = do_analyse(Module, Analysis, Level, C),
  		    reply(From, R),
  		    State
  		catch throw:Reason ->
  			reply(From,{error, {not_cover_compiled,Module}}),
  			not_loaded(Module, Reason, State)
  		end,
  	    main_process_loop(S);
  
  	{From, {{analyse_to_file, OutFile, Opts},Module}} ->
  	    S = try 
  		    Loaded = is_loaded(Module, State),
  		    File = case Loaded of
  			{loaded, File0} ->
  			    [{Module,Clauses}] = 
  				ets:lookup(?COVER_TABLE,Module),
  			    collect(Module, Clauses,
  				    State#main_state.nodes),
  			    File0;
  			{imported, File0, _} ->
  			    File0
  		    end,
  		    case find_source(File) of
  			{beam,_BeamFile} ->
  			    reply(From, {error,no_source_code_found}),
  			    State;
  			ErlFile ->
  			    analyse_info(Module,State#main_state.imported),
  			    HTML = lists:member(html,Opts),
  			    R = do_analyse_to_file(Module,OutFile,
  						   ErlFile,HTML),
  			    reply(From, R),
  			    State
  		    end
  		catch throw:Reason ->
  			reply(From,{error, {not_cover_compiled,Module}}),
  			not_loaded(Module, Reason, State)
  		end,
  	    main_process_loop(S);
  
  	{From, {is_compiled, Module}} ->
  	    S = try is_loaded(Module, State) of
  		    {loaded, File} ->
  			reply(From,{file, File}),
  			State;
  		    {imported,_File,_ImportFiles} ->
  			reply(From,false),
  			State
  		catch throw:Reason ->
  			reply(From,false),
  			not_loaded(Module, Reason, State)
  		end,
  	    main_process_loop(S);
  
  	{From, {reset, Module}} ->
  	    S = try 
  		    Loaded = is_loaded(Module,State),
  		    R = case Loaded of
  			    {loaded, _File} ->
  				do_reset_main_node(
  				  Module, State#main_state.nodes);
  			    {imported, _File, _} ->
  				do_reset_collection_table(Module)
  			end,
  		    Imported = 
  			remove_imported(Module,
  					State#main_state.imported),
  		    reply(From, R),
  		    State#main_state{imported=Imported}
  		catch throw:Reason ->
  			reply(From,{error, {not_cover_compiled,Module}}),
  			not_loaded(Module, Reason, State)
  		end,
  	    main_process_loop(S);		    
  	
  	{'EXIT',Pid,_Reason} ->
  	    %% Exit is trapped on the main node only, so this will only happen 
  