anchor.diff:               end,
   
       validate_bs_skip(Fail, Ctx, Stride, Vst);
  -vi_safe({test,bs_test_tail2,{f,Fail},[Ctx,_Size]}, Vst) ->
  +vi({test,bs_test_tail2,{f,Fail},[Ctx,_Size]}, Vst) ->
       assert_no_exception(Fail),
       assert_type(#t_bs_context{}, Ctx, Vst),
       branch(Fail, Vst);
  -vi_safe({test,bs_test_unit,{f,Fail},[Ctx,Unit]}, Vst) ->
  +vi({test,bs_test_unit,{f,Fail},[Ctx,Unit]}, Vst) ->
       assert_type(#t_bs_context{}, Ctx, Vst),
       type_test(Fail, #t_bs_context{tail_unit=Unit}, Ctx, Vst);
  -vi_safe({test,bs_skip_utf8,{f,Fail},[Ctx,Live,_]}, Vst) ->
  +vi({test,bs_skip_utf8,{f,Fail},[Ctx,Live,_]}, Vst) ->
       validate_bs_skip(Fail, Ctx, 8, Live, Vst);
  -vi_safe({test,bs_skip_utf16,{f,Fail},[Ctx,Live,_]}, Vst) ->
  +vi({test,bs_skip_utf16,{f,Fail},[Ctx,Live,_]}, Vst) ->
       validate_bs_skip(Fail, Ctx, 16, Live, Vst);
  -vi_safe({test,bs_skip_utf32,{f,Fail},[Ctx,Live,_]}, Vst) ->
  +vi({test,bs_skip_utf32,{f,Fail},[Ctx,Live,_]}, Vst) ->
       validate_bs_skip(Fail, Ctx, 32, Live, Vst);
  -vi_safe({test,bs_get_integer2=Op,{f,Fail},Live,
  -          [Ctx,{integer,Size},Unit,{field_flags,Flags}],Dst},Vst) ->
  +vi({test,bs_get_integer2=Op,{f,Fail},Live,
  +    [Ctx,{integer,Size},Unit,{field_flags,Flags}],Dst},Vst) ->
       NumBits = Size * Unit,
       Type = case member(unsigned, Flags) of
                  true when 0 =< NumBits, NumBits =< 64 ->
  
positive.code:         #{} ->
              error(local_call_to_unknown_function)
      end;
  verify_call_args(_, Live, Vst) when is_integer(Live)->
      verify_remote_args_1(Live - 1, Vst);
  verify_call_args(_, Live, _) ->
      error({bad_number_of_live_regs,Live}).
  
  verify_remote_args_1(-1, _) ->
      ok;
  
negative.code:                    end, {#{}, 1}, Elements),
      Type = #t_tuple{exact=true,size=Size,elements=Es},
      create_term(Type, put_tuple2, [], Dst, Vst);
  vi({put_tuple,Sz,Dst}, Vst0) when is_integer(Sz) ->
      Vst1 = eat_heap(1, Vst0),
      Vst = create_term(#t_abstract{kind=unfinished_tuple}, put_tuple, [],
                        Dst, Vst1),
      #vst{current=St0} = Vst,
      St = St0#st{puts_left={Sz,{Dst,Sz,#{}}}},
      Vst#vst{current=St};
  vi({put,Src}, Vst0) ->
      assert_term(Src, Vst0),
      Vst = eat_heap(1, Vst0),
      #vst{current=St0} = Vst,
  