anchor.diff:  
   app_modules(Data) ->
       Modules = lists:foldl(fun({_File, Code}, R) ->
  -        case re:run(Code, "module\\((\\w+)\\)", [{capture, all, list}]) of
  +        case re:run(Code, "module\\((" ++ ?ATOM_PATTERN ++ ")\\)", [{capture, all, list}]) of
               {match, [_, Module]} ->
                   [Module | R];
               nomatch ->
  
positive.code: %%% vim: set ts=4 sts=4 sw=4 et:
  
  -define('TMP_FILENAME', "/tmp/get_implicit_deps.tmp").
  
  main([Help]) when Help =:= "?"; Help =:= "-h"; Help =:= "--help"; Help =:= "help" ->
      io:format("Usage:~n$0 <dirname>~n");
  
negative.code: 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.
  