anchor.diff:  	    residualize_var(R, S);
   	false ->
   	    S1 = st__mark_inner_pending(L, S),
  -	    case catch {ok, visit(Opnd, S1)} of
  -		{ok, {E, S2}} ->
  +	    try visit(Opnd, S1) of
  +		{E, S2} ->
   		    %% Note that we pass the current environment and
   		    %% context to `copy', but not the current renaming.
   		    S3 = st__clear_inner_pending(L, S2),
  -		    copy(R, Opnd, E, Ctxt, Env, S3);
  -		{'EXIT', X} ->
  -		    exit(X);
  -		X ->
  +		    copy(R, Opnd, E, Ctxt, Env, S3)
  +	    catch
  +		throw:X ->
    		    %% If we use destructive update for the
    		    %% `inner-pending' flag, we must make sure to clear
    		    %% it also if we make a nonlocal return.
  
positive.code:     %% close to zero at this point. (This is an extension to the
      %% original algorithm.)
      S1 = new_active_size(Limit + apply_size(length(Ctxt#app.opnds)), S),
      case catch {ok, inline(E, Ctxt, ren__identity(), Env, S1)} of
          {ok, {E1, S2}} ->
              %% Revert to the old size counter.
              {E1, revert_size(S, S2)};
          {counter_exceeded, size, S2} ->
              %% Aborted this inlining attempt because it got too big.
              %% Residualize the variable and revert to the old size
              %% counter. (It is important that we do not also revert the
  
negative.code:             copy_inline_2(R, E, Ctxt, Env, S);
          false ->
              S1 = new_active_effort(get_effort_limit(S), S),
              try copy_inline_2(R, E, Ctxt, Env, S1) of
                  {E1, S2} ->
                      %% Revert to the old effort counter.
                      {E1, revert_effort(S, S2)}
  	    catch
                  throw:{counter_exceeded, effort, _} ->
                      %% Aborted this inlining attempt because too much
                      %% effort was spent. Residualize the variable and
                      %% revert to the previous state.
                      residualize_var(R, S)
              end
      end.
  
  