anchor.diff:  rescue_guards(_, Var, nil, _) -> { Var, false };
   
   rescue_guards(Line, Var, Guards, S) ->
  -  { Elixir, Erlang, Safe } = rescue_each_guard(Line, Var, Guards, [], [], true, S),
  +  { RawElixir, RawErlang } = rescue_each_var(Line, Var, Guards),
  +  { Elixir, Erlang, Safe } = rescue_each_ref(Line, Var, Guards, RawElixir, RawErlang, RawErlang == [], S),
   
     Final = case Elixir == [] of
       true  -> Erlang;
  
positive.code:     Safe
    }.
  
  %% Handle each clause expression detecting if it is
  %% an Erlang exception or not.
  
  rescue_each_guard(Line, { '_', _, _ } = Var, [{ '^', _, [H]}|T], Elixir, Erlang, _Safe, S) ->
    rescue_each_guard(Line, Var, T, [exception_compare(Line, Var, H)|Elixir], Erlang, false, S);
  
  rescue_each_guard(Line, Var, [{ '^', _, [H]}|T], Elixir, Erlang, _Safe, S) ->
    NewElixir = exception_compare(Line, Var, H),
    NewErlang = lists:map(fun(X) ->
      { 'andalso', Line, [
        { '==', Line, [X, H] },
        erlang_rescue_guard_for(Line, Var, X)
      ] }
    end, defined_erlang_rescue()),
    rescue_each_guard(Line, Var, T, [NewElixir|Elixir], NewErlang ++ Erlang, false, S);
  
  rescue_each_guard(Line, Var, [H|T], Elixir, Erlang, _Safe, S) when
    (H == '::UndefinedFunctionError') orelse (H == '::ErlangError') ->
    Expr = erlang_rescue_guard_for(Line, Var, H),
    rescue_each_guard(Line, Var, T, Elixir, [Expr|Erlang], false, S);
  
  rescue_each_guard(Line, Var, [H|T], Elixir, Erlang, Safe, S) when is_atom(H) ->
    rescue_each_guard(Line, Var, T, [exception_compare(Line, Var, H)|Elixir], Erlang, Safe, S);
  
  rescue_each_guard(Line, Var, [H|T], Elixir, Erlang, Safe, S) ->
    case translate_each(H, S) of
      { { atom, _, Atom }, _ } ->
        rescue_each_guard(Line, Var, [Atom|T], Elixir, Erlang, Safe, S);
      _ ->
        rescue_each_guard(Line, Var, T, [exception_compare(Line, Var, H)|Elixir], Erlang, Safe, S)
    end;
  
  rescue_each_guard(_, _, [], Elixir, Erlang, Safe, _) ->
    { Elixir, Erlang, Safe }.
  
  erlang_rescue_guard_for(Line, Var, '::UndefinedFunctionError') ->
    { '==', Line, [Var, undef] };
  
negative.code:   ] },
    { 'orelse', Line, [IsNotTuple, IsException] }.
  
  %% Join the given expression forming a tree according to the given kind.
  
  exception_compare(Line, Var, Expr) ->
  