anchor.diff:      error({invalid_tag_register,Src}).
   
   %% get_raw_type(Src, ValidatorState) -> Type
  -%%  Return the type of a register without doing any validity checks.
  +%%  Return the type of a register without doing any validity checks or
  +%%  conversions.
   get_raw_type({x,X}=Src, #vst{current=#st{xs=Xs}}=Vst) when is_integer(X) ->
       check_limit(Src),
       case Xs of
  
positive.code: %%  a standard Erlang type (no catch/try tags or match contexts).
  
  get_term_type(Src, Vst) ->
      case get_move_term_type(Src, Vst) of
          #ms{} -> error({match_context,Src});
          Type -> Type
      end.
  
  %% get_move_term_type(Src, ValidatorState) -> Type
  %%  Get the type of the source Src. The returned type Type will be
  %%  a standard Erlang type (no catch/try tags). Match contexts are OK.
  
  get_move_term_type(Src, Vst) ->
      case get_raw_type(Src, Vst) of
          initialized -> error({unassigned,Src});
          uninitialized -> error({uninitialized_reg,Src});
          {catchtag,_} -> error({catchtag,Src});
          {trytag,_} -> error({trytag,Src});
          tuple_in_progress -> error({tuple_in_progress,Src});
          Type -> Type
      end.
  
  
negative.code:     ok;
  verify_local_args(X, Lbl, CtxIds, Vst) ->
      Reg = {x, X},
      assert_not_fragile(Reg, Vst),
      case get_movable_term_type(Reg, Vst) of
          #ms{id=Id}=Type ->
              case CtxIds of
                  #{ Id := Other } ->
  