anchor.diff:  %%%
   vi_throwing({badmatch,Src}, Vst) ->
       assert_durable_term(Src, Vst),
  -    verify_y_init(Vst),
  -    kill_state(Vst);
  +    branch(?EXCEPTION_LABEL, Vst, fun kill_state/1);
   vi_throwing({case_end,Src}, Vst) ->
       assert_durable_term(Src, Vst),
  -    verify_y_init(Vst),
  -    kill_state(Vst);
  +    branch(?EXCEPTION_LABEL, Vst, fun kill_state/1);
   vi_throwing(if_end, Vst) ->
  -    verify_y_init(Vst),
  -    kill_state(Vst);
  +    branch(?EXCEPTION_LABEL, Vst, fun kill_state/1);
   vi_throwing({try_case_end,Src}, Vst) ->
  -    verify_y_init(Vst),
       assert_durable_term(Src, Vst),
  -    kill_state(Vst);
  +    branch(?EXCEPTION_LABEL, Vst, fun kill_state/1);
   vi_throwing({call_fun,Live}, Vst) ->
       Fun = {x,Live},
       assert_term(Fun, Vst),
  
positive.code:     verify_call_args(make_fun, NumFree, Vst),
      verify_y_init(Vst),
  
      create_term(#t_fun{arity=Arity}, make_fun, [], {x,0}, Vst);
  vi_throwing(raw_raise=I, Vst) ->
      call(I, 3, Vst);
  vi_throwing({wait_timeout,_,Src}, Vst) ->
      %% Note that the receive marker is not cleared since we may re-enter the
      %% loop while waiting. If we time out we'll be transferred to a timeout
      %% instruction that clears the marker.
      assert_term(Src, Vst),
      verify_y_init(Vst),
      prune_x_regs(0, Vst);
  vi_throwing(send, Vst) ->
      call(send, 2, Vst);
  vi_throwing({bs_add,{f,Fail},[A,B,_],Dst}, Vst) ->
      assert_term(A, Vst),
      assert_term(B, Vst),
  
negative.code: branch(Fail, Vst, SuccFun) ->
      branch(Fail, Vst, fun(V) -> V end, SuccFun).
  
  %% Shorthand of branch/4 for when the state is neither altered on failure nor
  %% success.
  branch(Fail, Vst) ->
      branch(Fail, Vst, fun(V) -> V end).
  
  %% Directly branches off the state. This is an "internal" operation that should
  %% be used sparingly.
  fork_state(?EXCEPTION_LABEL, Vst0) ->
      #vst{current=#st{ct=CatchTags}} = Vst0,
  
      %% Floating-point exceptions must be checked before any other kind of
      %% exception can be raised.
      assert_float_checked(Vst0),
  
      %% The stack will be scanned looking for a catch tag, so all Y registers
      %% must be initialized.
      verify_y_init(Vst0),
  
      case CatchTags of
          [{_, [Fail]} | _] when is_integer(Fail) ->
              true = Fail =/= ?EXCEPTION_LABEL,   %Assertion.
              %% Clear the receive marker and fork to our exception handler.
              Vst = set_receive_marker(none, Vst0),
              fork_state(Fail, Vst);
          [] ->
              %% No catch handler; the exception leaves the function.
              Vst0;
          _ ->
              error(ambiguous_catch_try_state)
      end;
  fork_state(L, #vst{current=St0,branched=Branched0,ref_ctr=Counter0}=Vst) ->
      {St, Counter} = merge_states(L, St0, Branched0, Counter0),
      Branched = Branched0#{ L => St },
  