anchor.diff:  mf2str({M, F}) ->
       atom_to_list(M) ++ ":" ++ atom_to_list(F).
   
  -can_apply(M, F) ->
  -    case lists:member(M, ['MODULE',
  -        application,
  -        application_controller,
  -        application_master,
  -        asn1ct,
  -        base64,
  -        binary,
  -        calendar,
  -        code,
  -        crypto,
  -        dict,
  -        digraph,
  -        digraph_utils,
  -        disk_log,
  -        erl_epmd,
  -        erl_parse,
  -        erl_scan,
  -        erl_syntax,
  -        erl_syntax_lib,
  -        erlang,
  -        error_logger,
  -        ets,
  -        file,
  -        filename,
  -        file_sorter,
  -        ftp,
  -        gb_trees,
  -        gen,
  -        gen_event,
  -        gen_server,
  -        gen_tcp,
  -        gen_udp,
  -        http_uri,
  -        httpc,
  -        httpd_util,
  -        inet,
  -        inet_db,
  -        inet_parse,
  -        inets,
  -        io,
  -        io_lib,
  -        lists,
  -        math,
  -        net_adm,
  -        ordsets,
  -        os,
  -        proplists,
  -        prim_inet,
  -        public_key,
  -        queue,
  -        random,
  -        re,
  -        rpc,
  -        sets,
  -        ssl,
  -        string,
  -        supervisor,
  -        sys,
  -        timer,
  -        unicode,
  -        xmerl_scan,
  -        zlib
  -    ]) of
  -        true ->
  -            true;
  -        false ->
  -            case can_apply(M, F, 0) of
  -                {true, N} ->
  -                    io:format("EXISTS: ~s:~s/~p~n", [M, F, N]),
  -                    true;
  -                false -> false
  -            end
  -    end.
  -
  -can_apply(_M, _F, 10) -> false;
  -can_apply(M, F, N) ->
  -    try
  -        apply(M, F, lists:seq(1, N)),
  -        {true, N}
  -    catch
  -        error:undef ->
  -            can_apply(M, F, N + 1);
  -        _:_ ->
  -            {true, N}
  -    end.
  +can_apply(error, _F) -> true;
  +can_apply(throw, _F) -> true;
  +can_apply(exit, _F) -> true;
  +can_apply('MODULE', _F) -> true;
  +can_apply(M, _F) ->
  +    case get(M) of
  +        undefined ->
  +            Result = module_exists(M),
  +            put(M, Result),
  +            Result;
  +        Result ->
  +            Result
  +    end.
  +
  +module_exists(M) ->
  +    case code:which(M) of
  +        non_existing ->
  +            false;
  +        _ ->
  +            true
  +    end.
  
positive.code:     Grep = fun(Pattern) ->
          cmd("cd " ++ Dirname ++ " && grep -nIR \"" ++ Pattern ++ "\" * | grep -v \"\.eunit\" >> " ++ ?TMP_FILENAME)
      end,
      ok = Grep("[0-9a-z]*:[0-9a-z]*"),
      ok = Grep("apply(\\s*[0-9a-z]*\\s*,\\s*[0-9a-z]*\\s*,"),
      ok = Grep("module\\([0-9a-z]*\\)"),
  
      Lines = read_file(?TMP_FILENAME),
      ok = cmd("rm " ++ ?TMP_FILENAME),
  
negative.code:     lists:usort([{{list_to_atom(M), list_to_atom(F)}, File} || {{M, F}, File} <- Functions]).
  
  % private functions
  
  regexp(lb, bash, _Save) ->
      "(";
  regexp(lb, erlang, Save) ->
      "\\" ++ regexp(lb, bash, Save);
  regexp(rb, bash, _Save) ->
      ")";
  regexp(rb, erlang, Save) ->
      "\\" ++ regexp(rb, bash, Save);
  
  regexp(atom, Type, true) ->
      "(" ++ regexp(atom, Type, false) ++ ")";
  regexp(atom, _Type, false) ->
      "[a-zA-Z][a-zA-Z0-9_]*";
  
  regexp(module, Type, Save) ->
      "module" ++ regexp(lb, Type, Save) ++ regexp(atom, Type, Save) ++ regexp(rb, Type, Save);
  regexp({function, v1}, Type, Save) ->
      regexp(atom, Type, Save) ++ ":" ++ regexp(atom, Type, Save);
  regexp({function, v2}, Type, Save) ->
      "apply\\s*" ++ regexp(lb, Type, Save) ++ "\\s*" ++ regexp(atom, Type, Save) ++ "\\s*,\\s*" ++ regexp(atom, Type, Save) ++ "\\s*,";
  regexp(_, _, _) ->
      erlang:error(badarg).
  
  code_search(Code, RegExpName, Info) ->
      case re:run(Code, regexp(RegExpName, erlang, true), [global, {capture, all, list}]) of
          {match, Match} ->
              [{list_to_tuple(T), Info} || [_ | T] <- Match];
          nomatch ->
              []
      end.
  
  read_file(Filename) ->
      case file:open(Filename, [raw, binary, read, exclusive, read_ahead]) of
  