anchor.diff:      error(ambiguous_catch_try_state).
   
   %% Handle the remaining floating point instructions here.
  -%% Floating point.
   vi_float({fconv,Src,{fr,_}=Dst}, Vst) ->
       assert_term(Src, Vst),
   
  
positive.code:     Vs = Vs0#{ Ref => Entry#value{type=Type} },
      Vst#vst{current=St#st{vs=Vs}}.
  
  new_value(Type, Op, Ss, #vst{current=#st{vs=Vs0}=St,ref_ctr=Counter}=Vst) ->
      Ref = #value_ref{id=Counter},
      Vs = Vs0#{ Ref => #value{op=Op,args=Ss,type=Type} },
  
negative.code: %% have clobbered the sources.
  %%
  
  validate_bif(Kind, Op, Fail, Ss, Dst, OrigVst, Vst0) ->
      assert_float_checked(Vst0),
      case {will_bif_succeed(Op, Ss, Vst0), Fail} of
          {yes, _} ->
              %% This BIF cannot fail (neither throw nor branch), handle it here
              %% without updating catch state.
              validate_bif_1(Kind, Op, cannot_fail, Ss, Dst, OrigVst, Vst0);
          {no, 0} ->
              %% The stack will be scanned, so Y registers must be initialized.
              Vst = branch_exception(Vst0),
              verify_y_init(Vst),
              kill_state(Vst);
          {no, _} ->
              %% The next instruction is never executed, this is essentially a
              %% direct jump.
              branch(Fail, Vst0, fun(SuccVst) -> kill_state(SuccVst) end);
          {maybe, 0} ->
              %% The BIF might throw an exception, make sure that any catch state
              %% is updated.
              Vst = branch_exception(Vst0),
              validate_bif_1(Kind, Op, Fail, Ss, Dst, OrigVst, Vst);
          {maybe, _} ->
              validate_bif_1(Kind, Op, Fail, Ss, Dst, OrigVst, Vst0)
      end.
  
  validate_bif_1(Kind, Op, cannot_fail, Ss, Dst, OrigVst, Vst0) ->
      %% This BIF explicitly cannot fail; it will not jump to a guard nor throw
  