anchor.diff:                     Transforms)
       end.
   
  -updated_merged_params(MsgName, FieldDef, AnRes, NewValue, Params) ->
  +updated_merged_params(MsgName, FieldDef, AnRes, NewValue, Params, Opts) ->
       #field{name=FName, rnum=RNum} = FieldDef,
       case get_field_pass(MsgName, AnRes) of
           pass_as_params ->
  
positive.code:      || {{msg, MsgName}, MsgDef} <- Defs].
  
  format_msg_decoder(MsgName, MsgDef, AnRes, Opts) ->
      [format_msg_decoder_read_field(MsgName, MsgDef, AnRes),
       format_field_decoders(MsgName, MsgDef, AnRes, Opts),
       format_field_skippers(MsgName, AnRes)].
  
  format_msg_decoder_read_field(MsgName, MsgDef, AnRes) ->
      Key = ?expr(Key),
      Rest = ?expr(Rest),
      Params = decoder_params(MsgName, AnRes),
      Bindings = new_bindings([{'<Params>', Params},
                               {'<Key>', Key},
                               {'<Rest>', Rest}]),
      [format_msg_init_decoder(MsgName, MsgDef, AnRes),
       format_msg_fastpath_decoder(Bindings, MsgName, MsgDef, AnRes),
       format_msg_generic_decoder(Bindings, MsgName, MsgDef, AnRes)].
  
  format_msg_init_decoder(MsgName, MsgDef, AnRes) ->
      gpb_codegen:format_fn(
        mk_fn(d_msg_, MsgName),
        fun(Bin) -> '<decode-field-fp>'(Bin, 0, 0, '<initial-params>') end,
        [replace_term('<decode-field-fp>', mk_fn(dfp_read_field_def_, MsgName)),
         splice_trees('<initial-params>',
                      msg_decoder_initial_params(MsgName, MsgDef, AnRes))]).
  
  format_msg_fastpath_decoder(Bindings, MsgName, MsgDef, AnRes) ->
      %% The fast-path decoder directly matches the minimal varint form
      %% of the field-number combined with the wiretype.
      %% Unrecognized fields fall back to the more generic decoder-loop
  
negative.code: 
  %% -- verifiers -----------------------------------------------------
  
  format_verifiers_top_function(Defs, Opts) ->
      Mapping = get_records_or_maps_by_opts(Opts),
      MsgNameVars = case Mapping of
                        records -> [];
                        maps    -> [?expr(MsgName)]
                    end,
      gpb_codegen:format_fn(
        verify_msg,
        fun(Msg, '<MsgName>') ->
                case '<MsgOrMsgName>' of
                    '<msg-match>' -> '<verify-msg>'(Msg, ['<MsgName>']);
                    _ -> mk_type_error(not_a_known_message, Msg, [])
                end
        end,
        [repeat_clauses(
           '<msg-match>',
           [[replace_tree('<msg-match>',
                          case Mapping of
                              records -> record_match(MsgName, []);
                              maps    -> erl_syntax:atom(MsgName)
                          end),
             replace_term('<verify-msg>', mk_fn(v_msg_, MsgName)),
             replace_term('<MsgName>', MsgName)]
            || {{msg, MsgName}, _MsgDef} <- Defs]),
         replace_tree('<MsgOrMsgName>', case Mapping of
                                            records -> ?expr(Msg);
                                            maps    -> ?expr(MsgName)
                                        end),
         splice_trees('<MsgName>', MsgNameVars)]).
  
  format_verifiers(Defs, AnRes, Opts) ->
      [format_msg_verifiers(Defs, AnRes, Opts),
       format_enum_verifiers(Defs, AnRes),
       format_type_verifiers(AnRes),
       format_verifier_auxiliaries()
      ].
  
  format_msg_verifiers(Defs, AnRes, Opts) ->
      [format_msg_verifier(MsgName, MsgDef, AnRes, Opts)
       || {{msg,MsgName}, MsgDef} <- Defs].
  
  format_msg_verifier(MsgName, MsgDef, AnRes, Opts) ->
      FVars = [{var_f_n(I), Field} || {I, Field} <- index_seq(MsgDef)],
      RFields = [{FName, Var} || {Var, #field{name=FName}} <- FVars],
      NeedsMatchOther = case get_records_or_maps_by_opts(Opts) of
                            records -> can_occur_as_sub_msg(MsgName, AnRes);
                            maps    -> true
                        end,
      gpb_codegen:format_fn(
        mk_fn(v_msg_, MsgName),
        fun('<msg-match>', '<Path>') ->
  