anchor.diff:  map_types(TypeStrings) ->
       Types = lists:map(fun list_to_atom/1, TypeStrings),
       case lists:all(fun (T) -> lists:member(T, ?report_types) end, Types) of
  -    true -> Types;
  -    false -> usage("argument to -t must be one or more of ~w~n",
  -                   [?report_types])
  +        true -> Types;
  +        false -> usage("argument to -t must be one or more of ~w~n",
  +                       [?report_types])
       end.
   
   start() ->
       Options = case parse_arguments([{h, 0, undefined, false},
  -                               {n, 1, fun list_to_integer/1, all},
  -                               {e, 1, undefined, undefined},
  -                               {t, one_or_more, fun map_types/1, all},
  -                               {report_dir, 1, undefined}],
  -                               init:get_arguments()) of
  -    {ok, O} -> O;
  -    {parse_error, badarg, n, _} -> usage("-n requires a single integer argument~n", []);
  -    {missing_option, K} -> usage("option ~p is required~n", [K]);
  -    {parse_error, {wrong_number_of_args, _, N}, K, _} -> usage("option ~p requires ~p arguments~n", [K, N]);
  -    Error -> usage("parse error: ~p~n", [Error])
  -    end,
  +                                    {n, 1, fun list_to_integer/1, all},
  +                                    {e, 1, undefined, undefined},
  +                                    {t, one_or_more, fun map_types/1, all},
  +                                    {report_dir, 1, undefined}],
  +                                   init:get_arguments()) of
  +                  {ok, O} ->
  +                      O;
  +                  {parse_error, badarg, n, _} ->
  +                      usage("-n requires a single integer argument~n", []);
  +                  {missing_option, K} ->
  +                      usage("option ~p is required~n", [K]);
  +                  {parse_error, {wrong_number_of_args, _, N}, K, _} ->
  +                      usage("option ~p requires ~p arguments~n", [K, N]);
  +                  Error -> usage("parse error: ~p~n", [Error])
  +              end,
       case proplists:get_value(h, Options) of
  -    true -> usage();
  -    false -> ok
  +        true -> usage();
  +        false -> ok
       end,
       Dir = proplists:get_value(report_dir, Options),
       Types = proplists:get_value(t, Options),
  
positive.code:                        [{report_dir, LogDir}|Options]
                 end,
      case rb:start(Options1) of
      {ok, _Pid} -> ok;
      {error, already_present} ->
          % Can sometimes get wedged
          supervisor:delete_child(sasl_sup, rb_server),
          erlang:error(try_again);
      {error, Reason} ->
          erlang:error(Reason)
      end,
      case RegExp of
      [] -> rb:show();
      _ -> rb:grep(RegExp)
      end,
      catch rb:stop(),
      TempFile.
  
negative.code:     NumReports = proplists:get_value(n, Options),
      rb:start([{report_dir, Dir}, {type, Types}, {max, NumReports}]),
      case RegExp of
          undefined -> rb:show();
          E -> io:format("grepping for ~p~n", [E]), rb:grep(E)
      end.
  
  get_logs_as_file(Types, NumReports, RegExp) ->
  