anchor.diff:  	_Other -> instrument_subtrees(Tree)
       end.
   
  -%% Return {ModuleAtom, FunctionAtom, ArgTree} for a function call that is going
  -%% to be instrumented or 'no_instr' otherwise.
  +%% Return {ModuleAtom, FunctionAtom, [ArgTree]} for a function call that
  +%% is going to be instrumented or 'no_instr' otherwise.
   get_mfa(Tree) ->
       Qualifier = erl_syntax:application_operator(Tree),
       case erl_syntax:type(Qualifier) of
   	atom ->
   	    Function = erl_syntax:atom_value(Qualifier),
               ArgTree = erl_syntax:application_arguments(Tree),
  -            needs_instrument(erlang, Function, ArgTree, ?INSTR_ERLANG_NO_MOD);
  +            needs_instrument(Function, ArgTree);
   	module_qualifier ->
   	    ModTree = erl_syntax:module_qualifier_argument(Qualifier),
   	    FunTree = erl_syntax:module_qualifier_body(Qualifier),
  
positive.code: 		erl_syntax:type(FunTree) =:= atom of
  		true ->
  		    Module = erl_syntax:atom_value(ModTree),
  		    case Module of
  			erlang ->
                              Function = erl_syntax:atom_value(FunTree),
                              ArgTree = erl_syntax:application_arguments(Tree),
                              needs_instrument(Module, Function, ArgTree,
                                               ?INSTR_ERLANG);
  			_Other -> no_instr
  		    end;
  		false -> no_instr
  	    end;
  	_Other -> no_instr
      end.
  
  %% Determine whether a function call needs instrumentation.
  needs_instrument(Module, Function, ArgTree, InstrList) ->
      Arity = length(ArgTree),
      case lists:member({Function, Arity}, InstrList) of
          true -> {Module, Function, ArgTree};
          false -> no_instr
      end.
  
  %% Instrument an application (function call).
  instrument_application({erlang, Fun, ArgTree}) ->
      ModTree = erl_syntax:atom(?REP_MOD),
      FunTree = erl_syntax:atom(list_to_atom("rep_" ++ atom_to_list(Fun))),
      erl_syntax:application(ModTree, FunTree, ArgTree).
  
  %% Instrument a receive expression.
  %% ----------------------------------------------------------------------
  
negative.code: 	 {whereis, 1}]).
  
  %% Instrumented functions called as erlang:FUNCTION.
  -define(INSTR_ERL_MOD_FUN,
  	[{erlang, send, 2}, {erlang, send, 3}] ++ 
  	[{erlang, F, A} || {F, A} <- ?INSTR_ERL_FUN]).
  
  %% Instrumented mod:fun.
  -define(INSTR_MOD_FUN, ?INSTR_ERL_MOD_FUN).
  
  %% Module containing replacement functions.
  -define(REP_MOD, rep).
  