anchor.diff:      create_tag(initialized, init, [], Reg, Vst);
   vi_safe({test_heap,Heap,Live}, Vst) ->
       test_heap(Heap, Live, Vst);
  -vi_safe({bif,Op,{f,0},Ss,Dst}=I, Vst0) ->
  -    case will_bif_succeed(Op, Ss, Vst0) of
  -        yes ->
  -            %% This BIF cannot fail, handle it here without updating catch
  -            %% state.
  -            validate_bif(Op, cannot_fail, Ss, Dst, Vst0);
  -        no ->
  -            %% The stack will be scanned, so Y registers must be initialized.
  -            Vst = branch_exception(Vst0),
  -            verify_y_init(Vst),
  -            kill_state(Vst);
  -        maybe ->
  -            %% The BIF can fail, make sure that any catch state is updated.
  -            Vst = branch_exception(Vst0),
  -            vi_float(I, Vst)
  -    end;
  -vi_safe({gc_bif,Op,{f,0},Live,Ss,Dst}=I, Vst0) ->
  -    case will_bif_succeed(Op, Ss, Vst0) of
  -        yes ->
  -            validate_gc_bif(Op, cannot_fail, Ss, Dst, Live, Vst0);
  -        no ->
  -            Vst = branch_exception(Vst0),
  -            verify_y_init(Vst),
  -            kill_state(Vst);
  -        maybe ->
  -            Vst = branch_exception(Vst0),
  -            assert_float_checked(Vst),
  -            vi_float(I, Vst)
  -    end;
   %% Put instructions.
   vi_safe({put_list,A,B,Dst}, Vst0) ->
       Vst = eat_heap(2, Vst0),
  
positive.code: %% have clobbered the sources.
  %%
  
  validate_bif(Op, Fail, Ss, Dst, Vst) ->
      validate_src(Ss, Vst),
      validate_bif_1(bif, Op, Fail, Ss, Dst, Vst, Vst).
  
  validate_gc_bif(Op, Fail, Ss, Dst, Live, #vst{current=St0}=Vst0) ->
      validate_src(Ss, Vst0),
      verify_live(Live, Vst0),
      verify_y_init(Vst0),
  
      %% Heap allocations and X registers are killed regardless of whether we
      %% fail or not, as we may fail after GC.
      St = kill_heap_allocation(St0),
      Vst = prune_x_regs(Live, Vst0#vst{current=St}),
      validate_src(Ss, Vst),
  
      validate_bif_1(gc_bif, Op, Fail, Ss, Dst, Vst, Vst).
  
  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
  
negative.code:     verify_put_map(Op, Fail, Src, Dst, Live, List, Vst);
  vi_safe({get_map_elements,{f,Fail},Src,{list,List}}, Vst) ->
      verify_get_map(Fail, Src, List, Vst);
  
  %%
  %% BIF calls
  %%
  %% These are technically not safe instructions since they may throw an
  %% exception when Fail =:= 0, but validate_bif/7 handles float error checking
  %% and exception branching when needed.
  %%
  vi_safe({bif,Op,{f,Fail},Ss,Dst}, Vst0) ->
      case is_float_arith_bif(Op, Ss) of
          true ->
              %% Float arithmetic BIFs neither fail nor throw an exception;
              %% errors are postponed until the next fcheckerror instruction.
              0 = Fail,                           %Assertion.
              validate_float_arith_bif(Ss, Dst, Vst0);
          false ->
              validate_src(Ss, Vst0),
              validate_bif(bif, Op, Fail, Ss, Dst, Vst0, Vst0)
      end;
  vi_safe({gc_bif,Op,{f,Fail},Live,Ss,Dst}, Vst0) ->
      validate_src(Ss, Vst0),
      verify_live(Live, Vst0),
      verify_y_init(Vst0),
  
      %% Heap allocations and X registers are killed regardless of whether we
      %% fail or not, as we may fail after GC.
      #vst{current=St0} = Vst0,
      St = kill_heap_allocation(St0),
      Vst = prune_x_regs(Live, Vst0#vst{current=St}),
  
      validate_bif(gc_bif, Op, Fail, Ss, Dst, Vst0, Vst);
  
  vi_safe(I, Vst0) ->
      Vst = branch_exception(Vst0),
      vi_float(I, Vst).
  