anchor.diff:  			   end
   		     end
   	     end,
  -    case refac_syntax:type(Node) of
  -      receive_expr -> true;
  -      infix_expr -> Op = refac_syntax:operator_literal(refac_syntax:infix_expr_operator(Node)),
  -		    Op == "!";
  -      fun_expr -> false;
  -      implicit_fun -> false;
  -      application ->
  -	  Operator = refac_syntax:application_operator(Node),
  -	  Arity = length(refac_syntax:application_arguments(Node)),
  -	  case refac_syntax:type(Operator) of
  -	    atom ->
  -		Op = refac_syntax:atom_value(Operator),
  -		{value, {fun_def, {M, _N, _A, _P1, _P}}} = lists:keysearch(fun_def, 1, refac_syntax:get_ann(Operator)),
  -		LookUp({M, Op, Arity});
  -	    module_qualifier ->
  -		Mod = refac_syntax:module_qualifier_argument(Operator),
  -		Body = refac_syntax:module_qualifier_body(Operator),
  -		case {refac_syntax:type(Mod), refac_syntax:type(Body)} of
  -		  {atom, atom} ->
  -		      M = refac_syntax:atom_value(Mod),
  -		      Op = refac_syntax:atom_value(Body),
  -		      LookUp({M, Op, Arity});
  -		  _ -> unknown
  -		end;
  -	    _ -> unknown
  -	  end;
  -      arity_qualifier ->
  -	  Fun = refac_syntax:arity_qualifier_body(Node),
  -	  A = refac_syntax:arity_qualifier_argument(Node),
  -	  case {refac_syntax:type(Fun), refac_syntax:type(A)} of
  -	    {atom, integer} ->
  -		FunName = refac_syntax:atom_value(Fun),
  -		Arity = refac_syntax:integer_value(A),
  -		{value, {fun_def, {M, _N, _A, _P1, _P}}} = lists:keysearch(fun_def, 1, refac_syntax:get_ann(FunName)),
  -		LookUp({M, FunName, Arity});
  -	    _ -> unknown
  -	  end;
  -      atom -> false;
  -      _ ->
  -	  case refac_syntax:subtrees(Node) of
  -	    [] -> false;
  -	    Ts ->
  -		Res = lists:flatten([[check_side_effect(T, LibPlt, LocalPlt) || T <- G] || G <- Ts]),
  -		case lists:member(true, Res) of
  -		  true -> true;
  -		  false ->
  -		      case lists:member(unknown, Res) of
  -			true -> unknown;
  +    case refac_syntax:is_literal(Node) of 
  +	true -> 
  +	    false;
  +	_ ->
  +	    case refac_syntax:type(Node) of
  +		receive_expr -> true;
  +		infix_expr -> Op = refac_syntax:operator_literal(refac_syntax:infix_expr_operator(Node)),
  +			      Op == "!";
  +		fun_expr -> false;
  +		implicit_fun -> false;
  +		application ->
  +		    Operator = refac_syntax:application_operator(Node),
  +		    Arity = length(refac_syntax:application_arguments(Node)),
  +		    case refac_syntax:type(Operator) of
  +			atom ->
  +			    Op = refac_syntax:atom_value(Operator),
  +			    {value, {fun_def, {M, _N, _A, _P1, _P}}} = lists:keysearch(fun_def, 1, refac_syntax:get_ann(Operator)),
  +			    LookUp({M, Op, Arity});
  +			module_qualifier ->
  +			    Mod = refac_syntax:module_qualifier_argument(Operator),
  +			    Body = refac_syntax:module_qualifier_body(Operator),
  +			    case {refac_syntax:type(Mod), refac_syntax:type(Body)} of
  +				{atom, atom} ->
  +				    M = refac_syntax:atom_value(Mod),
  +				    Op = refac_syntax:atom_value(Body),
  +				    LookUp({M, Op, Arity});
  +				_ -> unknown
  +			    end;
  +			_ -> unknown
  +		    end;
  +		arity_qualifier ->
  +		    Fun = refac_syntax:arity_qualifier_body(Node),
  +		    A = refac_syntax:arity_qualifier_argument(Node),
  +		    case {refac_syntax:type(Fun), refac_syntax:type(A)} of
  +			{atom, integer} ->
  +			    FunName = refac_syntax:atom_value(Fun),
  +			    Arity = refac_syntax:integer_value(A),
  +			    {value, {fun_def, {M, _N, _A, _P1, _P}}} = lists:keysearch(fun_def, 1, refac_syntax:get_ann(FunName)),
  +			    LookUp({M, FunName, Arity});
  +			_ -> unknown
  +		    end;
  +		atom -> false;
  +		_ ->
  +		    case refac_syntax:subtrees(Node) of
  +			[] -> false;
  +			Ts ->
  +			    Res = lists:flatten([[check_side_effect(T, LibPlt, LocalPlt) || T <- G] || G <- Ts]),
  +			    case lists:member(true, Res) of
  +				true -> true;
  +				false ->
  +				    case lists:member(unknown, Res) of
  +					true -> unknown;
   			_ -> false
  -		      end
  -		end
  -	  end
  +				    end
  +			    end
  +		    end
  +	    end
       end.
   
   normalise_file_name(Filename) ->
  
positive.code:     check_side_effect(Def, Side_Effect_Tab, OtherTab).
  
  
  
  check_side_effect(Node, LibPlt, LocalPlt) ->
      LookUp = fun (MFA) ->
  		     case lookup(LibPlt, MFA) of
  
negative.code: has_side_effect(_File, Node, _SearchPaths) ->
      LibSideEffectFile = list_to_atom(filename:join(?WRANGLER_DIR, "plt/side_effect_plt")),
      LibPlt = from_dets(lib_side_effect_plt, LibSideEffectFile),
      try  check_side_effect(Node, LibPlt, none) of
  	 true -> 
  	    dets:close(LibSideEffectFile),
  	    ets:delete(LibPlt),
  	    true;
  	 false -> dets:close(LibSideEffectFile),
  		  ets:delete(LibPlt),
  		  false;
  	 unknown ->
  	    dets:close(LibSideEffectFile),
  	    ets:delete(LibPlt),
  	    unknown
      catch
  	_E1:_E2 ->
  	    unknown
      end.
  
   %% The following is too slow for a large project.
  