// Code generated by protoc-gen-go-pulsar. DO NOT EDIT.
package testpb

import (
	v1beta1 "cosmossdk.io/api/cosmos/tx/v1beta1"
	binary "encoding/binary"
	fmt "fmt"
	runtime "github.com/cosmos/cosmos-proto/runtime"
	_ "github.com/cosmos/gogoproto/gogoproto"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoiface "google.golang.org/protobuf/runtime/protoiface"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	io "io"
	math "math"
	reflect "reflect"
	sort "sort"
	sync "sync"
)

var (
	md_Customer1                  protoreflect.MessageDescriptor
	fd_Customer1_id               protoreflect.FieldDescriptor
	fd_Customer1_name             protoreflect.FieldDescriptor
	fd_Customer1_subscription_fee protoreflect.FieldDescriptor
	fd_Customer1_payment          protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Customer1 = File_testpb_unknonwnproto_proto.Messages().ByName("Customer1")
	fd_Customer1_id = md_Customer1.Fields().ByName("id")
	fd_Customer1_name = md_Customer1.Fields().ByName("name")
	fd_Customer1_subscription_fee = md_Customer1.Fields().ByName("subscription_fee")
	fd_Customer1_payment = md_Customer1.Fields().ByName("payment")
}

var _ protoreflect.Message = (*fastReflection_Customer1)(nil)

type fastReflection_Customer1 Customer1

func (x *Customer1) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Customer1)(x)
}

func (x *Customer1) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Customer1_messageType fastReflection_Customer1_messageType
var _ protoreflect.MessageType = fastReflection_Customer1_messageType{}

type fastReflection_Customer1_messageType struct{}

func (x fastReflection_Customer1_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Customer1)(nil)
}
func (x fastReflection_Customer1_messageType) New() protoreflect.Message {
	return new(fastReflection_Customer1)
}
func (x fastReflection_Customer1_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Customer1
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Customer1) Descriptor() protoreflect.MessageDescriptor {
	return md_Customer1
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Customer1) Type() protoreflect.MessageType {
	return _fastReflection_Customer1_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Customer1) New() protoreflect.Message {
	return new(fastReflection_Customer1)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Customer1) Interface() protoreflect.ProtoMessage {
	return (*Customer1)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Customer1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Customer1_id, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Customer1_name, value) {
			return
		}
	}
	if x.SubscriptionFee != float32(0) || math.Signbit(float64(x.SubscriptionFee)) {
		value := protoreflect.ValueOfFloat32(x.SubscriptionFee)
		if !f(fd_Customer1_subscription_fee, value) {
			return
		}
	}
	if x.Payment != "" {
		value := protoreflect.ValueOfString(x.Payment)
		if !f(fd_Customer1_payment, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Customer1) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Customer1.id":
		return x.Id != int32(0)
	case "testpb.Customer1.name":
		return x.Name != ""
	case "testpb.Customer1.subscription_fee":
		return x.SubscriptionFee != float32(0) || math.Signbit(float64(x.SubscriptionFee))
	case "testpb.Customer1.payment":
		return x.Payment != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1"))
		}
		panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer1) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Customer1.id":
		x.Id = int32(0)
	case "testpb.Customer1.name":
		x.Name = ""
	case "testpb.Customer1.subscription_fee":
		x.SubscriptionFee = float32(0)
	case "testpb.Customer1.payment":
		x.Payment = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1"))
		}
		panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Customer1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Customer1.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Customer1.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.Customer1.subscription_fee":
		value := x.SubscriptionFee
		return protoreflect.ValueOfFloat32(value)
	case "testpb.Customer1.payment":
		value := x.Payment
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1"))
		}
		panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Customer1.id":
		x.Id = int32(value.Int())
	case "testpb.Customer1.name":
		x.Name = value.Interface().(string)
	case "testpb.Customer1.subscription_fee":
		x.SubscriptionFee = float32(value.Float())
	case "testpb.Customer1.payment":
		x.Payment = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1"))
		}
		panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Customer1.id":
		panic(fmt.Errorf("field id of message testpb.Customer1 is not mutable"))
	case "testpb.Customer1.name":
		panic(fmt.Errorf("field name of message testpb.Customer1 is not mutable"))
	case "testpb.Customer1.subscription_fee":
		panic(fmt.Errorf("field subscription_fee of message testpb.Customer1 is not mutable"))
	case "testpb.Customer1.payment":
		panic(fmt.Errorf("field payment of message testpb.Customer1 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1"))
		}
		panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Customer1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Customer1.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Customer1.name":
		return protoreflect.ValueOfString("")
	case "testpb.Customer1.subscription_fee":
		return protoreflect.ValueOfFloat32(float32(0))
	case "testpb.Customer1.payment":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer1"))
		}
		panic(fmt.Errorf("message testpb.Customer1 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Customer1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Customer1", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Customer1) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer1) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Customer1) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Customer1) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Customer1)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.SubscriptionFee != 0 || math.Signbit(float64(x.SubscriptionFee)) {
			n += 5
		}
		l = len(x.Payment)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Customer1)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.Payment) > 0 {
			i -= len(x.Payment)
			copy(dAtA[i:], x.Payment)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Payment)))
			i--
			dAtA[i] = 0x3a
		}
		if x.SubscriptionFee != 0 || math.Signbit(float64(x.SubscriptionFee)) {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.SubscriptionFee))))
			i--
			dAtA[i] = 0x1d
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Customer1)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer1: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer1: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 5 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SubscriptionFee", wireType)
				}
				var v uint32
				if (iNdEx + 4) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				x.SubscriptionFee = float32(math.Float32frombits(v))
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Payment", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Payment = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Customer2               protoreflect.MessageDescriptor
	fd_Customer2_id            protoreflect.FieldDescriptor
	fd_Customer2_industry      protoreflect.FieldDescriptor
	fd_Customer2_name          protoreflect.FieldDescriptor
	fd_Customer2_fewer         protoreflect.FieldDescriptor
	fd_Customer2_reserved      protoreflect.FieldDescriptor
	fd_Customer2_city          protoreflect.FieldDescriptor
	fd_Customer2_miscellaneous protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Customer2 = File_testpb_unknonwnproto_proto.Messages().ByName("Customer2")
	fd_Customer2_id = md_Customer2.Fields().ByName("id")
	fd_Customer2_industry = md_Customer2.Fields().ByName("industry")
	fd_Customer2_name = md_Customer2.Fields().ByName("name")
	fd_Customer2_fewer = md_Customer2.Fields().ByName("fewer")
	fd_Customer2_reserved = md_Customer2.Fields().ByName("reserved")
	fd_Customer2_city = md_Customer2.Fields().ByName("city")
	fd_Customer2_miscellaneous = md_Customer2.Fields().ByName("miscellaneous")
}

var _ protoreflect.Message = (*fastReflection_Customer2)(nil)

type fastReflection_Customer2 Customer2

func (x *Customer2) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Customer2)(x)
}

func (x *Customer2) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Customer2_messageType fastReflection_Customer2_messageType
var _ protoreflect.MessageType = fastReflection_Customer2_messageType{}

type fastReflection_Customer2_messageType struct{}

func (x fastReflection_Customer2_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Customer2)(nil)
}
func (x fastReflection_Customer2_messageType) New() protoreflect.Message {
	return new(fastReflection_Customer2)
}
func (x fastReflection_Customer2_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Customer2
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Customer2) Descriptor() protoreflect.MessageDescriptor {
	return md_Customer2
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Customer2) Type() protoreflect.MessageType {
	return _fastReflection_Customer2_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Customer2) New() protoreflect.Message {
	return new(fastReflection_Customer2)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Customer2) Interface() protoreflect.ProtoMessage {
	return (*Customer2)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Customer2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Customer2_id, value) {
			return
		}
	}
	if x.Industry != int32(0) {
		value := protoreflect.ValueOfInt32(x.Industry)
		if !f(fd_Customer2_industry, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Customer2_name, value) {
			return
		}
	}
	if x.Fewer != float32(0) || math.Signbit(float64(x.Fewer)) {
		value := protoreflect.ValueOfFloat32(x.Fewer)
		if !f(fd_Customer2_fewer, value) {
			return
		}
	}
	if x.Reserved != int64(0) {
		value := protoreflect.ValueOfInt64(x.Reserved)
		if !f(fd_Customer2_reserved, value) {
			return
		}
	}
	if x.City != 0 {
		value := protoreflect.ValueOfEnum((protoreflect.EnumNumber)(x.City))
		if !f(fd_Customer2_city, value) {
			return
		}
	}
	if x.Miscellaneous != nil {
		value := protoreflect.ValueOfMessage(x.Miscellaneous.ProtoReflect())
		if !f(fd_Customer2_miscellaneous, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Customer2) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Customer2.id":
		return x.Id != int32(0)
	case "testpb.Customer2.industry":
		return x.Industry != int32(0)
	case "testpb.Customer2.name":
		return x.Name != ""
	case "testpb.Customer2.fewer":
		return x.Fewer != float32(0) || math.Signbit(float64(x.Fewer))
	case "testpb.Customer2.reserved":
		return x.Reserved != int64(0)
	case "testpb.Customer2.city":
		return x.City != 0
	case "testpb.Customer2.miscellaneous":
		return x.Miscellaneous != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2"))
		}
		panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer2) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Customer2.id":
		x.Id = int32(0)
	case "testpb.Customer2.industry":
		x.Industry = int32(0)
	case "testpb.Customer2.name":
		x.Name = ""
	case "testpb.Customer2.fewer":
		x.Fewer = float32(0)
	case "testpb.Customer2.reserved":
		x.Reserved = int64(0)
	case "testpb.Customer2.city":
		x.City = 0
	case "testpb.Customer2.miscellaneous":
		x.Miscellaneous = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2"))
		}
		panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Customer2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Customer2.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Customer2.industry":
		value := x.Industry
		return protoreflect.ValueOfInt32(value)
	case "testpb.Customer2.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.Customer2.fewer":
		value := x.Fewer
		return protoreflect.ValueOfFloat32(value)
	case "testpb.Customer2.reserved":
		value := x.Reserved
		return protoreflect.ValueOfInt64(value)
	case "testpb.Customer2.city":
		value := x.City
		return protoreflect.ValueOfEnum((protoreflect.EnumNumber)(value))
	case "testpb.Customer2.miscellaneous":
		value := x.Miscellaneous
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2"))
		}
		panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Customer2.id":
		x.Id = int32(value.Int())
	case "testpb.Customer2.industry":
		x.Industry = int32(value.Int())
	case "testpb.Customer2.name":
		x.Name = value.Interface().(string)
	case "testpb.Customer2.fewer":
		x.Fewer = float32(value.Float())
	case "testpb.Customer2.reserved":
		x.Reserved = value.Int()
	case "testpb.Customer2.city":
		x.City = (Customer2_City)(value.Enum())
	case "testpb.Customer2.miscellaneous":
		x.Miscellaneous = value.Message().Interface().(*anypb.Any)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2"))
		}
		panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Customer2.miscellaneous":
		if x.Miscellaneous == nil {
			x.Miscellaneous = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.Miscellaneous.ProtoReflect())
	case "testpb.Customer2.id":
		panic(fmt.Errorf("field id of message testpb.Customer2 is not mutable"))
	case "testpb.Customer2.industry":
		panic(fmt.Errorf("field industry of message testpb.Customer2 is not mutable"))
	case "testpb.Customer2.name":
		panic(fmt.Errorf("field name of message testpb.Customer2 is not mutable"))
	case "testpb.Customer2.fewer":
		panic(fmt.Errorf("field fewer of message testpb.Customer2 is not mutable"))
	case "testpb.Customer2.reserved":
		panic(fmt.Errorf("field reserved of message testpb.Customer2 is not mutable"))
	case "testpb.Customer2.city":
		panic(fmt.Errorf("field city of message testpb.Customer2 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2"))
		}
		panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Customer2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Customer2.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Customer2.industry":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Customer2.name":
		return protoreflect.ValueOfString("")
	case "testpb.Customer2.fewer":
		return protoreflect.ValueOfFloat32(float32(0))
	case "testpb.Customer2.reserved":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.Customer2.city":
		return protoreflect.ValueOfEnum(0)
	case "testpb.Customer2.miscellaneous":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer2"))
		}
		panic(fmt.Errorf("message testpb.Customer2 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Customer2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Customer2", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Customer2) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer2) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Customer2) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Customer2) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Customer2)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		if x.Industry != 0 {
			n += 1 + runtime.Sov(uint64(x.Industry))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Fewer != 0 || math.Signbit(float64(x.Fewer)) {
			n += 5
		}
		if x.Reserved != 0 {
			n += 2 + runtime.Sov(uint64(x.Reserved))
		}
		if x.City != 0 {
			n += 1 + runtime.Sov(uint64(x.City))
		}
		if x.Miscellaneous != nil {
			l = options.Size(x.Miscellaneous)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Customer2)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Reserved != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Reserved))
			i--
			dAtA[i] = 0x41
			i--
			dAtA[i] = 0xb8
		}
		if x.Miscellaneous != nil {
			encoded, err := options.Marshal(x.Miscellaneous)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x52
		}
		if x.City != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.City))
			i--
			dAtA[i] = 0x30
		}
		if x.Fewer != 0 || math.Signbit(float64(x.Fewer)) {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.Fewer))))
			i--
			dAtA[i] = 0x25
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x1a
		}
		if x.Industry != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Industry))
			i--
			dAtA[i] = 0x10
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Customer2)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer2: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer2: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Industry", wireType)
				}
				x.Industry = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Industry |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 4:
				if wireType != 5 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fewer", wireType)
				}
				var v uint32
				if (iNdEx + 4) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				x.Fewer = float32(math.Float32frombits(v))
			case 1047:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Reserved", wireType)
				}
				x.Reserved = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Reserved |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 6:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType)
				}
				x.City = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.City |= Customer2_City(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 10:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Miscellaneous", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Miscellaneous == nil {
					x.Miscellaneous = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Miscellaneous); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Nested4A      protoreflect.MessageDescriptor
	fd_Nested4A_id   protoreflect.FieldDescriptor
	fd_Nested4A_name protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested4A = File_testpb_unknonwnproto_proto.Messages().ByName("Nested4A")
	fd_Nested4A_id = md_Nested4A.Fields().ByName("id")
	fd_Nested4A_name = md_Nested4A.Fields().ByName("name")
}

var _ protoreflect.Message = (*fastReflection_Nested4A)(nil)

type fastReflection_Nested4A Nested4A

func (x *Nested4A) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested4A)(x)
}

func (x *Nested4A) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[2]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested4A_messageType fastReflection_Nested4A_messageType
var _ protoreflect.MessageType = fastReflection_Nested4A_messageType{}

type fastReflection_Nested4A_messageType struct{}

func (x fastReflection_Nested4A_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested4A)(nil)
}
func (x fastReflection_Nested4A_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested4A)
}
func (x fastReflection_Nested4A_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested4A
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested4A) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested4A
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested4A) Type() protoreflect.MessageType {
	return _fastReflection_Nested4A_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested4A) New() protoreflect.Message {
	return new(fastReflection_Nested4A)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested4A) Interface() protoreflect.ProtoMessage {
	return (*Nested4A)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested4A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested4A_id, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Nested4A_name, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested4A) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested4A.id":
		return x.Id != int32(0)
	case "testpb.Nested4A.name":
		return x.Name != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A"))
		}
		panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4A) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested4A.id":
		x.Id = int32(0)
	case "testpb.Nested4A.name":
		x.Name = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A"))
		}
		panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested4A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested4A.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested4A.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A"))
		}
		panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested4A.id":
		x.Id = int32(value.Int())
	case "testpb.Nested4A.name":
		x.Name = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A"))
		}
		panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested4A.id":
		panic(fmt.Errorf("field id of message testpb.Nested4A is not mutable"))
	case "testpb.Nested4A.name":
		panic(fmt.Errorf("field name of message testpb.Nested4A is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A"))
		}
		panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested4A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested4A.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested4A.name":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4A"))
		}
		panic(fmt.Errorf("message testpb.Nested4A does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested4A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested4A", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested4A) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4A) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested4A) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested4A) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested4A)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested4A)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested4A)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4A: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4A: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_Nested3A_4_list)(nil)

type _Nested3A_4_list struct {
	list *[]*Nested4A
}

func (x *_Nested3A_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_Nested3A_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_Nested3A_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Nested4A)
	(*x.list)[i] = concreteValue
}

func (x *_Nested3A_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Nested4A)
	*x.list = append(*x.list, concreteValue)
}

func (x *_Nested3A_4_list) AppendMutable() protoreflect.Value {
	v := new(Nested4A)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Nested3A_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_Nested3A_4_list) NewElement() protoreflect.Value {
	v := new(Nested4A)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Nested3A_4_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.Map = (*_Nested3A_5_map)(nil)

type _Nested3A_5_map struct {
	m *map[int64]*Nested4A
}

func (x *_Nested3A_5_map) Len() int {
	if x.m == nil {
		return 0
	}
	return len(*x.m)
}

func (x *_Nested3A_5_map) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) {
	if x.m == nil {
		return
	}
	for k, v := range *x.m {
		mapKey := (protoreflect.MapKey)(protoreflect.ValueOfInt64(k))
		mapValue := protoreflect.ValueOfMessage(v.ProtoReflect())
		if !f(mapKey, mapValue) {
			break
		}
	}
}

func (x *_Nested3A_5_map) Has(key protoreflect.MapKey) bool {
	if x.m == nil {
		return false
	}
	keyUnwrapped := key.Int()
	concreteValue := keyUnwrapped
	_, ok := (*x.m)[concreteValue]
	return ok
}

func (x *_Nested3A_5_map) Clear(key protoreflect.MapKey) {
	if x.m == nil {
		return
	}
	keyUnwrapped := key.Int()
	concreteKey := keyUnwrapped
	delete(*x.m, concreteKey)
}

func (x *_Nested3A_5_map) Get(key protoreflect.MapKey) protoreflect.Value {
	if x.m == nil {
		return protoreflect.Value{}
	}
	keyUnwrapped := key.Int()
	concreteKey := keyUnwrapped
	v, ok := (*x.m)[concreteKey]
	if !ok {
		return protoreflect.Value{}
	}
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Nested3A_5_map) Set(key protoreflect.MapKey, value protoreflect.Value) {
	if !key.IsValid() || !value.IsValid() {
		panic("invalid key or value provided")
	}
	keyUnwrapped := key.Int()
	concreteKey := keyUnwrapped
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Nested4A)
	(*x.m)[concreteKey] = concreteValue
}

func (x *_Nested3A_5_map) Mutable(key protoreflect.MapKey) protoreflect.Value {
	keyUnwrapped := key.Int()
	concreteKey := keyUnwrapped
	v, ok := (*x.m)[concreteKey]
	if ok {
		return protoreflect.ValueOfMessage(v.ProtoReflect())
	}
	newValue := new(Nested4A)
	(*x.m)[concreteKey] = newValue
	return protoreflect.ValueOfMessage(newValue.ProtoReflect())
}

func (x *_Nested3A_5_map) NewValue() protoreflect.Value {
	v := new(Nested4A)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Nested3A_5_map) IsValid() bool {
	return x.m != nil
}

var (
	md_Nested3A       protoreflect.MessageDescriptor
	fd_Nested3A_id    protoreflect.FieldDescriptor
	fd_Nested3A_name  protoreflect.FieldDescriptor
	fd_Nested3A_a4    protoreflect.FieldDescriptor
	fd_Nested3A_index protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested3A = File_testpb_unknonwnproto_proto.Messages().ByName("Nested3A")
	fd_Nested3A_id = md_Nested3A.Fields().ByName("id")
	fd_Nested3A_name = md_Nested3A.Fields().ByName("name")
	fd_Nested3A_a4 = md_Nested3A.Fields().ByName("a4")
	fd_Nested3A_index = md_Nested3A.Fields().ByName("index")
}

var _ protoreflect.Message = (*fastReflection_Nested3A)(nil)

type fastReflection_Nested3A Nested3A

func (x *Nested3A) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested3A)(x)
}

func (x *Nested3A) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[3]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested3A_messageType fastReflection_Nested3A_messageType
var _ protoreflect.MessageType = fastReflection_Nested3A_messageType{}

type fastReflection_Nested3A_messageType struct{}

func (x fastReflection_Nested3A_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested3A)(nil)
}
func (x fastReflection_Nested3A_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested3A)
}
func (x fastReflection_Nested3A_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested3A
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested3A) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested3A
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested3A) Type() protoreflect.MessageType {
	return _fastReflection_Nested3A_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested3A) New() protoreflect.Message {
	return new(fastReflection_Nested3A)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested3A) Interface() protoreflect.ProtoMessage {
	return (*Nested3A)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested3A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested3A_id, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Nested3A_name, value) {
			return
		}
	}
	if len(x.A4) != 0 {
		value := protoreflect.ValueOfList(&_Nested3A_4_list{list: &x.A4})
		if !f(fd_Nested3A_a4, value) {
			return
		}
	}
	if len(x.Index) != 0 {
		value := protoreflect.ValueOfMap(&_Nested3A_5_map{m: &x.Index})
		if !f(fd_Nested3A_index, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested3A) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested3A.id":
		return x.Id != int32(0)
	case "testpb.Nested3A.name":
		return x.Name != ""
	case "testpb.Nested3A.a4":
		return len(x.A4) != 0
	case "testpb.Nested3A.index":
		return len(x.Index) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A"))
		}
		panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3A) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested3A.id":
		x.Id = int32(0)
	case "testpb.Nested3A.name":
		x.Name = ""
	case "testpb.Nested3A.a4":
		x.A4 = nil
	case "testpb.Nested3A.index":
		x.Index = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A"))
		}
		panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested3A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested3A.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested3A.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.Nested3A.a4":
		if len(x.A4) == 0 {
			return protoreflect.ValueOfList(&_Nested3A_4_list{})
		}
		listValue := &_Nested3A_4_list{list: &x.A4}
		return protoreflect.ValueOfList(listValue)
	case "testpb.Nested3A.index":
		if len(x.Index) == 0 {
			return protoreflect.ValueOfMap(&_Nested3A_5_map{})
		}
		mapValue := &_Nested3A_5_map{m: &x.Index}
		return protoreflect.ValueOfMap(mapValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A"))
		}
		panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested3A.id":
		x.Id = int32(value.Int())
	case "testpb.Nested3A.name":
		x.Name = value.Interface().(string)
	case "testpb.Nested3A.a4":
		lv := value.List()
		clv := lv.(*_Nested3A_4_list)
		x.A4 = *clv.list
	case "testpb.Nested3A.index":
		mv := value.Map()
		cmv := mv.(*_Nested3A_5_map)
		x.Index = *cmv.m
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A"))
		}
		panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested3A.a4":
		if x.A4 == nil {
			x.A4 = []*Nested4A{}
		}
		value := &_Nested3A_4_list{list: &x.A4}
		return protoreflect.ValueOfList(value)
	case "testpb.Nested3A.index":
		if x.Index == nil {
			x.Index = make(map[int64]*Nested4A)
		}
		value := &_Nested3A_5_map{m: &x.Index}
		return protoreflect.ValueOfMap(value)
	case "testpb.Nested3A.id":
		panic(fmt.Errorf("field id of message testpb.Nested3A is not mutable"))
	case "testpb.Nested3A.name":
		panic(fmt.Errorf("field name of message testpb.Nested3A is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A"))
		}
		panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested3A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested3A.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested3A.name":
		return protoreflect.ValueOfString("")
	case "testpb.Nested3A.a4":
		list := []*Nested4A{}
		return protoreflect.ValueOfList(&_Nested3A_4_list{list: &list})
	case "testpb.Nested3A.index":
		m := make(map[int64]*Nested4A)
		return protoreflect.ValueOfMap(&_Nested3A_5_map{m: &m})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3A"))
		}
		panic(fmt.Errorf("message testpb.Nested3A does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested3A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested3A", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested3A) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3A) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested3A) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested3A) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested3A)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.A4) > 0 {
			for _, e := range x.A4 {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.Index) > 0 {
			SiZeMaP := func(k int64, v *Nested4A) {
				l := 0
				if v != nil {
					l = options.Size(v)
				}
				l += 1 + runtime.Sov(uint64(l))
				mapEntrySize := 1 + runtime.Sov(uint64(k)) + l
				n += mapEntrySize + 1 + runtime.Sov(uint64(mapEntrySize))
			}
			if options.Deterministic {
				sortme := make([]int64, 0, len(x.Index))
				for k := range x.Index {
					sortme = append(sortme, k)
				}
				sort.Slice(sortme, func(i, j int) bool {
					return sortme[i] < sortme[j]
				})
				for _, k := range sortme {
					v := x.Index[k]
					SiZeMaP(k, v)
				}
			} else {
				for k, v := range x.Index {
					SiZeMaP(k, v)
				}
			}
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested3A)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.Index) > 0 {
			MaRsHaLmAp := func(k int64, v *Nested4A) (protoiface.MarshalOutput, error) {
				baseI := i
				encoded, err := options.Marshal(v)
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x12
				i = runtime.EncodeVarint(dAtA, i, uint64(k))
				i--
				dAtA[i] = 0x8
				i = runtime.EncodeVarint(dAtA, i, uint64(baseI-i))
				i--
				dAtA[i] = 0x2a
				return protoiface.MarshalOutput{}, nil
			}
			if options.Deterministic {
				keysForIndex := make([]int64, 0, len(x.Index))
				for k := range x.Index {
					keysForIndex = append(keysForIndex, int64(k))
				}
				sort.Slice(keysForIndex, func(i, j int) bool {
					return keysForIndex[i] < keysForIndex[j]
				})
				for iNdEx := len(keysForIndex) - 1; iNdEx >= 0; iNdEx-- {
					v := x.Index[int64(keysForIndex[iNdEx])]
					out, err := MaRsHaLmAp(keysForIndex[iNdEx], v)
					if err != nil {
						return out, err
					}
				}
			} else {
				for k := range x.Index {
					v := x.Index[k]
					out, err := MaRsHaLmAp(k, v)
					if err != nil {
						return out, err
					}
				}
			}
		}
		if len(x.A4) > 0 {
			for iNdEx := len(x.A4) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.A4[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested3A)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3A: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3A: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A4", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.A4 = append(x.A4, &Nested4A{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A4[len(x.A4)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Index == nil {
					x.Index = make(map[int64]*Nested4A)
				}
				var mapkey int64
				var mapvalue *Nested4A
				for iNdEx < postIndex {
					entryPreIndex := iNdEx
					var wire uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
						}
						if iNdEx >= l {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						wire |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					fieldNum := int32(wire >> 3)
					if fieldNum == 1 {
						for shift := uint(0); ; shift += 7 {
							if shift >= 64 {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
							}
							if iNdEx >= l {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
							}
							b := dAtA[iNdEx]
							iNdEx++
							mapkey |= int64(b&0x7F) << shift
							if b < 0x80 {
								break
							}
						}
					} else if fieldNum == 2 {
						var mapmsglen int
						for shift := uint(0); ; shift += 7 {
							if shift >= 64 {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
							}
							if iNdEx >= l {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
							}
							b := dAtA[iNdEx]
							iNdEx++
							mapmsglen |= int(b&0x7F) << shift
							if b < 0x80 {
								break
							}
						}
						if mapmsglen < 0 {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
						}
						postmsgIndex := iNdEx + mapmsglen
						if postmsgIndex < 0 {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
						}
						if postmsgIndex > l {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
						}
						mapvalue = &Nested4A{}
						if err := options.Unmarshal(dAtA[iNdEx:postmsgIndex], mapvalue); err != nil {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
						}
						iNdEx = postmsgIndex
					} else {
						iNdEx = entryPreIndex
						skippy, err := runtime.Skip(dAtA[iNdEx:])
						if err != nil {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
						}
						if (skippy < 0) || (iNdEx+skippy) < 0 {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
						}
						if (iNdEx + skippy) > postIndex {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
						}
						iNdEx += skippy
					}
				}
				x.Index[mapkey] = mapvalue
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Nested2A        protoreflect.MessageDescriptor
	fd_Nested2A_id     protoreflect.FieldDescriptor
	fd_Nested2A_name   protoreflect.FieldDescriptor
	fd_Nested2A_nested protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested2A = File_testpb_unknonwnproto_proto.Messages().ByName("Nested2A")
	fd_Nested2A_id = md_Nested2A.Fields().ByName("id")
	fd_Nested2A_name = md_Nested2A.Fields().ByName("name")
	fd_Nested2A_nested = md_Nested2A.Fields().ByName("nested")
}

var _ protoreflect.Message = (*fastReflection_Nested2A)(nil)

type fastReflection_Nested2A Nested2A

func (x *Nested2A) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested2A)(x)
}

func (x *Nested2A) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[4]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested2A_messageType fastReflection_Nested2A_messageType
var _ protoreflect.MessageType = fastReflection_Nested2A_messageType{}

type fastReflection_Nested2A_messageType struct{}

func (x fastReflection_Nested2A_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested2A)(nil)
}
func (x fastReflection_Nested2A_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested2A)
}
func (x fastReflection_Nested2A_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested2A
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested2A) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested2A
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested2A) Type() protoreflect.MessageType {
	return _fastReflection_Nested2A_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested2A) New() protoreflect.Message {
	return new(fastReflection_Nested2A)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested2A) Interface() protoreflect.ProtoMessage {
	return (*Nested2A)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested2A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested2A_id, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Nested2A_name, value) {
			return
		}
	}
	if x.Nested != nil {
		value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
		if !f(fd_Nested2A_nested, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested2A) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested2A.id":
		return x.Id != int32(0)
	case "testpb.Nested2A.name":
		return x.Name != ""
	case "testpb.Nested2A.nested":
		return x.Nested != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A"))
		}
		panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2A) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested2A.id":
		x.Id = int32(0)
	case "testpb.Nested2A.name":
		x.Name = ""
	case "testpb.Nested2A.nested":
		x.Nested = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A"))
		}
		panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested2A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested2A.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested2A.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.Nested2A.nested":
		value := x.Nested
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A"))
		}
		panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested2A.id":
		x.Id = int32(value.Int())
	case "testpb.Nested2A.name":
		x.Name = value.Interface().(string)
	case "testpb.Nested2A.nested":
		x.Nested = value.Message().Interface().(*Nested3A)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A"))
		}
		panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested2A.nested":
		if x.Nested == nil {
			x.Nested = new(Nested3A)
		}
		return protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
	case "testpb.Nested2A.id":
		panic(fmt.Errorf("field id of message testpb.Nested2A is not mutable"))
	case "testpb.Nested2A.name":
		panic(fmt.Errorf("field name of message testpb.Nested2A is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A"))
		}
		panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested2A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested2A.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested2A.name":
		return protoreflect.ValueOfString("")
	case "testpb.Nested2A.nested":
		m := new(Nested3A)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2A"))
		}
		panic(fmt.Errorf("message testpb.Nested2A does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested2A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested2A", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested2A) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2A) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested2A) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested2A) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested2A)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Nested != nil {
			l = options.Size(x.Nested)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested2A)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Nested != nil {
			encoded, err := options.Marshal(x.Nested)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested2A)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2A: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2A: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Nested == nil {
					x.Nested = &Nested3A{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Nested1A        protoreflect.MessageDescriptor
	fd_Nested1A_id     protoreflect.FieldDescriptor
	fd_Nested1A_nested protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested1A = File_testpb_unknonwnproto_proto.Messages().ByName("Nested1A")
	fd_Nested1A_id = md_Nested1A.Fields().ByName("id")
	fd_Nested1A_nested = md_Nested1A.Fields().ByName("nested")
}

var _ protoreflect.Message = (*fastReflection_Nested1A)(nil)

type fastReflection_Nested1A Nested1A

func (x *Nested1A) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested1A)(x)
}

func (x *Nested1A) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[5]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested1A_messageType fastReflection_Nested1A_messageType
var _ protoreflect.MessageType = fastReflection_Nested1A_messageType{}

type fastReflection_Nested1A_messageType struct{}

func (x fastReflection_Nested1A_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested1A)(nil)
}
func (x fastReflection_Nested1A_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested1A)
}
func (x fastReflection_Nested1A_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested1A
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested1A) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested1A
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested1A) Type() protoreflect.MessageType {
	return _fastReflection_Nested1A_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested1A) New() protoreflect.Message {
	return new(fastReflection_Nested1A)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested1A) Interface() protoreflect.ProtoMessage {
	return (*Nested1A)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested1A) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested1A_id, value) {
			return
		}
	}
	if x.Nested != nil {
		value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
		if !f(fd_Nested1A_nested, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested1A) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested1A.id":
		return x.Id != int32(0)
	case "testpb.Nested1A.nested":
		return x.Nested != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A"))
		}
		panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1A) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested1A.id":
		x.Id = int32(0)
	case "testpb.Nested1A.nested":
		x.Nested = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A"))
		}
		panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested1A) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested1A.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested1A.nested":
		value := x.Nested
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A"))
		}
		panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1A) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested1A.id":
		x.Id = int32(value.Int())
	case "testpb.Nested1A.nested":
		x.Nested = value.Message().Interface().(*Nested2A)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A"))
		}
		panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1A) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested1A.nested":
		if x.Nested == nil {
			x.Nested = new(Nested2A)
		}
		return protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
	case "testpb.Nested1A.id":
		panic(fmt.Errorf("field id of message testpb.Nested1A is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A"))
		}
		panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested1A) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested1A.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested1A.nested":
		m := new(Nested2A)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1A"))
		}
		panic(fmt.Errorf("message testpb.Nested1A does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested1A) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested1A", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested1A) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1A) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested1A) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested1A) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested1A)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		if x.Nested != nil {
			l = options.Size(x.Nested)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested1A)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Nested != nil {
			encoded, err := options.Marshal(x.Nested)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested1A)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1A: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1A: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Nested == nil {
					x.Nested = &Nested2A{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Nested4B      protoreflect.MessageDescriptor
	fd_Nested4B_id   protoreflect.FieldDescriptor
	fd_Nested4B_age  protoreflect.FieldDescriptor
	fd_Nested4B_name protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested4B = File_testpb_unknonwnproto_proto.Messages().ByName("Nested4B")
	fd_Nested4B_id = md_Nested4B.Fields().ByName("id")
	fd_Nested4B_age = md_Nested4B.Fields().ByName("age")
	fd_Nested4B_name = md_Nested4B.Fields().ByName("name")
}

var _ protoreflect.Message = (*fastReflection_Nested4B)(nil)

type fastReflection_Nested4B Nested4B

func (x *Nested4B) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested4B)(x)
}

func (x *Nested4B) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[6]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested4B_messageType fastReflection_Nested4B_messageType
var _ protoreflect.MessageType = fastReflection_Nested4B_messageType{}

type fastReflection_Nested4B_messageType struct{}

func (x fastReflection_Nested4B_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested4B)(nil)
}
func (x fastReflection_Nested4B_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested4B)
}
func (x fastReflection_Nested4B_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested4B
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested4B) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested4B
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested4B) Type() protoreflect.MessageType {
	return _fastReflection_Nested4B_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested4B) New() protoreflect.Message {
	return new(fastReflection_Nested4B)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested4B) Interface() protoreflect.ProtoMessage {
	return (*Nested4B)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested4B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested4B_id, value) {
			return
		}
	}
	if x.Age != int32(0) {
		value := protoreflect.ValueOfInt32(x.Age)
		if !f(fd_Nested4B_age, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Nested4B_name, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested4B) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested4B.id":
		return x.Id != int32(0)
	case "testpb.Nested4B.age":
		return x.Age != int32(0)
	case "testpb.Nested4B.name":
		return x.Name != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B"))
		}
		panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4B) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested4B.id":
		x.Id = int32(0)
	case "testpb.Nested4B.age":
		x.Age = int32(0)
	case "testpb.Nested4B.name":
		x.Name = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B"))
		}
		panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested4B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested4B.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested4B.age":
		value := x.Age
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested4B.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B"))
		}
		panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested4B.id":
		x.Id = int32(value.Int())
	case "testpb.Nested4B.age":
		x.Age = int32(value.Int())
	case "testpb.Nested4B.name":
		x.Name = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B"))
		}
		panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested4B.id":
		panic(fmt.Errorf("field id of message testpb.Nested4B is not mutable"))
	case "testpb.Nested4B.age":
		panic(fmt.Errorf("field age of message testpb.Nested4B is not mutable"))
	case "testpb.Nested4B.name":
		panic(fmt.Errorf("field name of message testpb.Nested4B is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B"))
		}
		panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested4B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested4B.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested4B.age":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested4B.name":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested4B"))
		}
		panic(fmt.Errorf("message testpb.Nested4B does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested4B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested4B", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested4B) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested4B) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested4B) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested4B) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested4B)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		if x.Age != 0 {
			n += 1 + runtime.Sov(uint64(x.Age))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested4B)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x1a
		}
		if x.Age != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Age))
			i--
			dAtA[i] = 0x10
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested4B)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4B: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested4B: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
				}
				x.Age = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Age |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_Nested3B_4_list)(nil)

type _Nested3B_4_list struct {
	list *[]*Nested4B
}

func (x *_Nested3B_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_Nested3B_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_Nested3B_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Nested4B)
	(*x.list)[i] = concreteValue
}

func (x *_Nested3B_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*Nested4B)
	*x.list = append(*x.list, concreteValue)
}

func (x *_Nested3B_4_list) AppendMutable() protoreflect.Value {
	v := new(Nested4B)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Nested3B_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_Nested3B_4_list) NewElement() protoreflect.Value {
	v := new(Nested4B)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_Nested3B_4_list) IsValid() bool {
	return x.list != nil
}

var (
	md_Nested3B      protoreflect.MessageDescriptor
	fd_Nested3B_id   protoreflect.FieldDescriptor
	fd_Nested3B_age  protoreflect.FieldDescriptor
	fd_Nested3B_name protoreflect.FieldDescriptor
	fd_Nested3B_b4   protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested3B = File_testpb_unknonwnproto_proto.Messages().ByName("Nested3B")
	fd_Nested3B_id = md_Nested3B.Fields().ByName("id")
	fd_Nested3B_age = md_Nested3B.Fields().ByName("age")
	fd_Nested3B_name = md_Nested3B.Fields().ByName("name")
	fd_Nested3B_b4 = md_Nested3B.Fields().ByName("b4")
}

var _ protoreflect.Message = (*fastReflection_Nested3B)(nil)

type fastReflection_Nested3B Nested3B

func (x *Nested3B) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested3B)(x)
}

func (x *Nested3B) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[7]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested3B_messageType fastReflection_Nested3B_messageType
var _ protoreflect.MessageType = fastReflection_Nested3B_messageType{}

type fastReflection_Nested3B_messageType struct{}

func (x fastReflection_Nested3B_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested3B)(nil)
}
func (x fastReflection_Nested3B_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested3B)
}
func (x fastReflection_Nested3B_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested3B
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested3B) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested3B
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested3B) Type() protoreflect.MessageType {
	return _fastReflection_Nested3B_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested3B) New() protoreflect.Message {
	return new(fastReflection_Nested3B)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested3B) Interface() protoreflect.ProtoMessage {
	return (*Nested3B)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested3B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested3B_id, value) {
			return
		}
	}
	if x.Age != int32(0) {
		value := protoreflect.ValueOfInt32(x.Age)
		if !f(fd_Nested3B_age, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Nested3B_name, value) {
			return
		}
	}
	if len(x.B4) != 0 {
		value := protoreflect.ValueOfList(&_Nested3B_4_list{list: &x.B4})
		if !f(fd_Nested3B_b4, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested3B) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested3B.id":
		return x.Id != int32(0)
	case "testpb.Nested3B.age":
		return x.Age != int32(0)
	case "testpb.Nested3B.name":
		return x.Name != ""
	case "testpb.Nested3B.b4":
		return len(x.B4) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B"))
		}
		panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3B) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested3B.id":
		x.Id = int32(0)
	case "testpb.Nested3B.age":
		x.Age = int32(0)
	case "testpb.Nested3B.name":
		x.Name = ""
	case "testpb.Nested3B.b4":
		x.B4 = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B"))
		}
		panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested3B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested3B.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested3B.age":
		value := x.Age
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested3B.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.Nested3B.b4":
		if len(x.B4) == 0 {
			return protoreflect.ValueOfList(&_Nested3B_4_list{})
		}
		listValue := &_Nested3B_4_list{list: &x.B4}
		return protoreflect.ValueOfList(listValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B"))
		}
		panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested3B.id":
		x.Id = int32(value.Int())
	case "testpb.Nested3B.age":
		x.Age = int32(value.Int())
	case "testpb.Nested3B.name":
		x.Name = value.Interface().(string)
	case "testpb.Nested3B.b4":
		lv := value.List()
		clv := lv.(*_Nested3B_4_list)
		x.B4 = *clv.list
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B"))
		}
		panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested3B.b4":
		if x.B4 == nil {
			x.B4 = []*Nested4B{}
		}
		value := &_Nested3B_4_list{list: &x.B4}
		return protoreflect.ValueOfList(value)
	case "testpb.Nested3B.id":
		panic(fmt.Errorf("field id of message testpb.Nested3B is not mutable"))
	case "testpb.Nested3B.age":
		panic(fmt.Errorf("field age of message testpb.Nested3B is not mutable"))
	case "testpb.Nested3B.name":
		panic(fmt.Errorf("field name of message testpb.Nested3B is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B"))
		}
		panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested3B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested3B.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested3B.age":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested3B.name":
		return protoreflect.ValueOfString("")
	case "testpb.Nested3B.b4":
		list := []*Nested4B{}
		return protoreflect.ValueOfList(&_Nested3B_4_list{list: &list})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested3B"))
		}
		panic(fmt.Errorf("message testpb.Nested3B does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested3B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested3B", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested3B) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested3B) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested3B) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested3B) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested3B)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		if x.Age != 0 {
			n += 1 + runtime.Sov(uint64(x.Age))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.B4) > 0 {
			for _, e := range x.B4 {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested3B)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.B4) > 0 {
			for iNdEx := len(x.B4) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.B4[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x1a
		}
		if x.Age != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Age))
			i--
			dAtA[i] = 0x10
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested3B)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3B: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested3B: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
				}
				x.Age = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Age |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B4", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.B4 = append(x.B4, &Nested4B{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B4[len(x.B4)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Nested2B        protoreflect.MessageDescriptor
	fd_Nested2B_id     protoreflect.FieldDescriptor
	fd_Nested2B_fee    protoreflect.FieldDescriptor
	fd_Nested2B_nested protoreflect.FieldDescriptor
	fd_Nested2B_route  protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested2B = File_testpb_unknonwnproto_proto.Messages().ByName("Nested2B")
	fd_Nested2B_id = md_Nested2B.Fields().ByName("id")
	fd_Nested2B_fee = md_Nested2B.Fields().ByName("fee")
	fd_Nested2B_nested = md_Nested2B.Fields().ByName("nested")
	fd_Nested2B_route = md_Nested2B.Fields().ByName("route")
}

var _ protoreflect.Message = (*fastReflection_Nested2B)(nil)

type fastReflection_Nested2B Nested2B

func (x *Nested2B) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested2B)(x)
}

func (x *Nested2B) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[8]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested2B_messageType fastReflection_Nested2B_messageType
var _ protoreflect.MessageType = fastReflection_Nested2B_messageType{}

type fastReflection_Nested2B_messageType struct{}

func (x fastReflection_Nested2B_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested2B)(nil)
}
func (x fastReflection_Nested2B_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested2B)
}
func (x fastReflection_Nested2B_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested2B
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested2B) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested2B
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested2B) Type() protoreflect.MessageType {
	return _fastReflection_Nested2B_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested2B) New() protoreflect.Message {
	return new(fastReflection_Nested2B)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested2B) Interface() protoreflect.ProtoMessage {
	return (*Nested2B)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested2B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested2B_id, value) {
			return
		}
	}
	if x.Fee != float64(0) || math.Signbit(x.Fee) {
		value := protoreflect.ValueOfFloat64(x.Fee)
		if !f(fd_Nested2B_fee, value) {
			return
		}
	}
	if x.Nested != nil {
		value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
		if !f(fd_Nested2B_nested, value) {
			return
		}
	}
	if x.Route != "" {
		value := protoreflect.ValueOfString(x.Route)
		if !f(fd_Nested2B_route, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested2B) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested2B.id":
		return x.Id != int32(0)
	case "testpb.Nested2B.fee":
		return x.Fee != float64(0) || math.Signbit(x.Fee)
	case "testpb.Nested2B.nested":
		return x.Nested != nil
	case "testpb.Nested2B.route":
		return x.Route != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B"))
		}
		panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2B) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested2B.id":
		x.Id = int32(0)
	case "testpb.Nested2B.fee":
		x.Fee = float64(0)
	case "testpb.Nested2B.nested":
		x.Nested = nil
	case "testpb.Nested2B.route":
		x.Route = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B"))
		}
		panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested2B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested2B.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested2B.fee":
		value := x.Fee
		return protoreflect.ValueOfFloat64(value)
	case "testpb.Nested2B.nested":
		value := x.Nested
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.Nested2B.route":
		value := x.Route
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B"))
		}
		panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested2B.id":
		x.Id = int32(value.Int())
	case "testpb.Nested2B.fee":
		x.Fee = value.Float()
	case "testpb.Nested2B.nested":
		x.Nested = value.Message().Interface().(*Nested3B)
	case "testpb.Nested2B.route":
		x.Route = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B"))
		}
		panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested2B.nested":
		if x.Nested == nil {
			x.Nested = new(Nested3B)
		}
		return protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
	case "testpb.Nested2B.id":
		panic(fmt.Errorf("field id of message testpb.Nested2B is not mutable"))
	case "testpb.Nested2B.fee":
		panic(fmt.Errorf("field fee of message testpb.Nested2B is not mutable"))
	case "testpb.Nested2B.route":
		panic(fmt.Errorf("field route of message testpb.Nested2B is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B"))
		}
		panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested2B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested2B.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested2B.fee":
		return protoreflect.ValueOfFloat64(float64(0))
	case "testpb.Nested2B.nested":
		m := new(Nested3B)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.Nested2B.route":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested2B"))
		}
		panic(fmt.Errorf("message testpb.Nested2B does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested2B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested2B", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested2B) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested2B) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested2B) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested2B) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested2B)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		if x.Fee != 0 || math.Signbit(x.Fee) {
			n += 9
		}
		if x.Nested != nil {
			l = options.Size(x.Nested)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.Route)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested2B)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.Route) > 0 {
			i -= len(x.Route)
			copy(dAtA[i:], x.Route)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Route)))
			i--
			dAtA[i] = 0x22
		}
		if x.Nested != nil {
			encoded, err := options.Marshal(x.Nested)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if x.Fee != 0 || math.Signbit(x.Fee) {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(x.Fee))))
			i--
			dAtA[i] = 0x11
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested2B)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2B: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested2B: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 1 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
				}
				var v uint64
				if (iNdEx + 8) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				x.Fee = float64(math.Float64frombits(v))
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Nested == nil {
					x.Nested = &Nested3B{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Route", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Route = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Nested1B        protoreflect.MessageDescriptor
	fd_Nested1B_id     protoreflect.FieldDescriptor
	fd_Nested1B_nested protoreflect.FieldDescriptor
	fd_Nested1B_age    protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Nested1B = File_testpb_unknonwnproto_proto.Messages().ByName("Nested1B")
	fd_Nested1B_id = md_Nested1B.Fields().ByName("id")
	fd_Nested1B_nested = md_Nested1B.Fields().ByName("nested")
	fd_Nested1B_age = md_Nested1B.Fields().ByName("age")
}

var _ protoreflect.Message = (*fastReflection_Nested1B)(nil)

type fastReflection_Nested1B Nested1B

func (x *Nested1B) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Nested1B)(x)
}

func (x *Nested1B) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[9]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Nested1B_messageType fastReflection_Nested1B_messageType
var _ protoreflect.MessageType = fastReflection_Nested1B_messageType{}

type fastReflection_Nested1B_messageType struct{}

func (x fastReflection_Nested1B_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Nested1B)(nil)
}
func (x fastReflection_Nested1B_messageType) New() protoreflect.Message {
	return new(fastReflection_Nested1B)
}
func (x fastReflection_Nested1B_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested1B
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Nested1B) Descriptor() protoreflect.MessageDescriptor {
	return md_Nested1B
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Nested1B) Type() protoreflect.MessageType {
	return _fastReflection_Nested1B_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Nested1B) New() protoreflect.Message {
	return new(fastReflection_Nested1B)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Nested1B) Interface() protoreflect.ProtoMessage {
	return (*Nested1B)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Nested1B) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Nested1B_id, value) {
			return
		}
	}
	if x.Nested != nil {
		value := protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
		if !f(fd_Nested1B_nested, value) {
			return
		}
	}
	if x.Age != int32(0) {
		value := protoreflect.ValueOfInt32(x.Age)
		if !f(fd_Nested1B_age, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Nested1B) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Nested1B.id":
		return x.Id != int32(0)
	case "testpb.Nested1B.nested":
		return x.Nested != nil
	case "testpb.Nested1B.age":
		return x.Age != int32(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B"))
		}
		panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1B) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Nested1B.id":
		x.Id = int32(0)
	case "testpb.Nested1B.nested":
		x.Nested = nil
	case "testpb.Nested1B.age":
		x.Age = int32(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B"))
		}
		panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Nested1B) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Nested1B.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Nested1B.nested":
		value := x.Nested
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.Nested1B.age":
		value := x.Age
		return protoreflect.ValueOfInt32(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B"))
		}
		panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1B) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Nested1B.id":
		x.Id = int32(value.Int())
	case "testpb.Nested1B.nested":
		x.Nested = value.Message().Interface().(*Nested2B)
	case "testpb.Nested1B.age":
		x.Age = int32(value.Int())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B"))
		}
		panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1B) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested1B.nested":
		if x.Nested == nil {
			x.Nested = new(Nested2B)
		}
		return protoreflect.ValueOfMessage(x.Nested.ProtoReflect())
	case "testpb.Nested1B.id":
		panic(fmt.Errorf("field id of message testpb.Nested1B is not mutable"))
	case "testpb.Nested1B.age":
		panic(fmt.Errorf("field age of message testpb.Nested1B is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B"))
		}
		panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Nested1B) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Nested1B.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Nested1B.nested":
		m := new(Nested2B)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.Nested1B.age":
		return protoreflect.ValueOfInt32(int32(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Nested1B"))
		}
		panic(fmt.Errorf("message testpb.Nested1B does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Nested1B) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Nested1B", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Nested1B) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Nested1B) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Nested1B) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Nested1B) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Nested1B)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		if x.Nested != nil {
			l = options.Size(x.Nested)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Age != 0 {
			n += 1 + runtime.Sov(uint64(x.Age))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Nested1B)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Age != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Age))
			i--
			dAtA[i] = 0x18
		}
		if x.Nested != nil {
			encoded, err := options.Marshal(x.Nested)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Nested1B)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1B: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Nested1B: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Nested == nil {
					x.Nested = &Nested2B{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nested); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Age", wireType)
				}
				x.Age = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Age |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_Customer3                protoreflect.MessageDescriptor
	fd_Customer3_id             protoreflect.FieldDescriptor
	fd_Customer3_name           protoreflect.FieldDescriptor
	fd_Customer3_sf             protoreflect.FieldDescriptor
	fd_Customer3_surcharge      protoreflect.FieldDescriptor
	fd_Customer3_destination    protoreflect.FieldDescriptor
	fd_Customer3_credit_card_no protoreflect.FieldDescriptor
	fd_Customer3_cheque_no      protoreflect.FieldDescriptor
	fd_Customer3_original       protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_Customer3 = File_testpb_unknonwnproto_proto.Messages().ByName("Customer3")
	fd_Customer3_id = md_Customer3.Fields().ByName("id")
	fd_Customer3_name = md_Customer3.Fields().ByName("name")
	fd_Customer3_sf = md_Customer3.Fields().ByName("sf")
	fd_Customer3_surcharge = md_Customer3.Fields().ByName("surcharge")
	fd_Customer3_destination = md_Customer3.Fields().ByName("destination")
	fd_Customer3_credit_card_no = md_Customer3.Fields().ByName("credit_card_no")
	fd_Customer3_cheque_no = md_Customer3.Fields().ByName("cheque_no")
	fd_Customer3_original = md_Customer3.Fields().ByName("original")
}

var _ protoreflect.Message = (*fastReflection_Customer3)(nil)

type fastReflection_Customer3 Customer3

func (x *Customer3) ProtoReflect() protoreflect.Message {
	return (*fastReflection_Customer3)(x)
}

func (x *Customer3) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[10]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_Customer3_messageType fastReflection_Customer3_messageType
var _ protoreflect.MessageType = fastReflection_Customer3_messageType{}

type fastReflection_Customer3_messageType struct{}

func (x fastReflection_Customer3_messageType) Zero() protoreflect.Message {
	return (*fastReflection_Customer3)(nil)
}
func (x fastReflection_Customer3_messageType) New() protoreflect.Message {
	return new(fastReflection_Customer3)
}
func (x fastReflection_Customer3_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_Customer3
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_Customer3) Descriptor() protoreflect.MessageDescriptor {
	return md_Customer3
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_Customer3) Type() protoreflect.MessageType {
	return _fastReflection_Customer3_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_Customer3) New() protoreflect.Message {
	return new(fastReflection_Customer3)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_Customer3) Interface() protoreflect.ProtoMessage {
	return (*Customer3)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_Customer3) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int32(0) {
		value := protoreflect.ValueOfInt32(x.Id)
		if !f(fd_Customer3_id, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_Customer3_name, value) {
			return
		}
	}
	if x.Sf != float32(0) || math.Signbit(float64(x.Sf)) {
		value := protoreflect.ValueOfFloat32(x.Sf)
		if !f(fd_Customer3_sf, value) {
			return
		}
	}
	if x.Surcharge != float32(0) || math.Signbit(float64(x.Surcharge)) {
		value := protoreflect.ValueOfFloat32(x.Surcharge)
		if !f(fd_Customer3_surcharge, value) {
			return
		}
	}
	if x.Destination != "" {
		value := protoreflect.ValueOfString(x.Destination)
		if !f(fd_Customer3_destination, value) {
			return
		}
	}
	if x.Payment != nil {
		switch o := x.Payment.(type) {
		case *Customer3_CreditCardNo:
			v := o.CreditCardNo
			value := protoreflect.ValueOfString(v)
			if !f(fd_Customer3_credit_card_no, value) {
				return
			}
		case *Customer3_ChequeNo:
			v := o.ChequeNo
			value := protoreflect.ValueOfString(v)
			if !f(fd_Customer3_cheque_no, value) {
				return
			}
		}
	}
	if x.Original != nil {
		value := protoreflect.ValueOfMessage(x.Original.ProtoReflect())
		if !f(fd_Customer3_original, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_Customer3) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.Customer3.id":
		return x.Id != int32(0)
	case "testpb.Customer3.name":
		return x.Name != ""
	case "testpb.Customer3.sf":
		return x.Sf != float32(0) || math.Signbit(float64(x.Sf))
	case "testpb.Customer3.surcharge":
		return x.Surcharge != float32(0) || math.Signbit(float64(x.Surcharge))
	case "testpb.Customer3.destination":
		return x.Destination != ""
	case "testpb.Customer3.credit_card_no":
		if x.Payment == nil {
			return false
		} else if _, ok := x.Payment.(*Customer3_CreditCardNo); ok {
			return true
		} else {
			return false
		}
	case "testpb.Customer3.cheque_no":
		if x.Payment == nil {
			return false
		} else if _, ok := x.Payment.(*Customer3_ChequeNo); ok {
			return true
		} else {
			return false
		}
	case "testpb.Customer3.original":
		return x.Original != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3"))
		}
		panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer3) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.Customer3.id":
		x.Id = int32(0)
	case "testpb.Customer3.name":
		x.Name = ""
	case "testpb.Customer3.sf":
		x.Sf = float32(0)
	case "testpb.Customer3.surcharge":
		x.Surcharge = float32(0)
	case "testpb.Customer3.destination":
		x.Destination = ""
	case "testpb.Customer3.credit_card_no":
		x.Payment = nil
	case "testpb.Customer3.cheque_no":
		x.Payment = nil
	case "testpb.Customer3.original":
		x.Original = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3"))
		}
		panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_Customer3) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.Customer3.id":
		value := x.Id
		return protoreflect.ValueOfInt32(value)
	case "testpb.Customer3.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.Customer3.sf":
		value := x.Sf
		return protoreflect.ValueOfFloat32(value)
	case "testpb.Customer3.surcharge":
		value := x.Surcharge
		return protoreflect.ValueOfFloat32(value)
	case "testpb.Customer3.destination":
		value := x.Destination
		return protoreflect.ValueOfString(value)
	case "testpb.Customer3.credit_card_no":
		if x.Payment == nil {
			return protoreflect.ValueOfString("")
		} else if v, ok := x.Payment.(*Customer3_CreditCardNo); ok {
			return protoreflect.ValueOfString(v.CreditCardNo)
		} else {
			return protoreflect.ValueOfString("")
		}
	case "testpb.Customer3.cheque_no":
		if x.Payment == nil {
			return protoreflect.ValueOfString("")
		} else if v, ok := x.Payment.(*Customer3_ChequeNo); ok {
			return protoreflect.ValueOfString(v.ChequeNo)
		} else {
			return protoreflect.ValueOfString("")
		}
	case "testpb.Customer3.original":
		value := x.Original
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3"))
		}
		panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer3) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.Customer3.id":
		x.Id = int32(value.Int())
	case "testpb.Customer3.name":
		x.Name = value.Interface().(string)
	case "testpb.Customer3.sf":
		x.Sf = float32(value.Float())
	case "testpb.Customer3.surcharge":
		x.Surcharge = float32(value.Float())
	case "testpb.Customer3.destination":
		x.Destination = value.Interface().(string)
	case "testpb.Customer3.credit_card_no":
		cv := value.Interface().(string)
		x.Payment = &Customer3_CreditCardNo{CreditCardNo: cv}
	case "testpb.Customer3.cheque_no":
		cv := value.Interface().(string)
		x.Payment = &Customer3_ChequeNo{ChequeNo: cv}
	case "testpb.Customer3.original":
		x.Original = value.Message().Interface().(*Customer1)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3"))
		}
		panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer3) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Customer3.original":
		if x.Original == nil {
			x.Original = new(Customer1)
		}
		return protoreflect.ValueOfMessage(x.Original.ProtoReflect())
	case "testpb.Customer3.id":
		panic(fmt.Errorf("field id of message testpb.Customer3 is not mutable"))
	case "testpb.Customer3.name":
		panic(fmt.Errorf("field name of message testpb.Customer3 is not mutable"))
	case "testpb.Customer3.sf":
		panic(fmt.Errorf("field sf of message testpb.Customer3 is not mutable"))
	case "testpb.Customer3.surcharge":
		panic(fmt.Errorf("field surcharge of message testpb.Customer3 is not mutable"))
	case "testpb.Customer3.destination":
		panic(fmt.Errorf("field destination of message testpb.Customer3 is not mutable"))
	case "testpb.Customer3.credit_card_no":
		panic(fmt.Errorf("field credit_card_no of message testpb.Customer3 is not mutable"))
	case "testpb.Customer3.cheque_no":
		panic(fmt.Errorf("field cheque_no of message testpb.Customer3 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3"))
		}
		panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_Customer3) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.Customer3.id":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.Customer3.name":
		return protoreflect.ValueOfString("")
	case "testpb.Customer3.sf":
		return protoreflect.ValueOfFloat32(float32(0))
	case "testpb.Customer3.surcharge":
		return protoreflect.ValueOfFloat32(float32(0))
	case "testpb.Customer3.destination":
		return protoreflect.ValueOfString("")
	case "testpb.Customer3.credit_card_no":
		return protoreflect.ValueOfString("")
	case "testpb.Customer3.cheque_no":
		return protoreflect.ValueOfString("")
	case "testpb.Customer3.original":
		m := new(Customer1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.Customer3"))
		}
		panic(fmt.Errorf("message testpb.Customer3 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_Customer3) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.Customer3.payment":
		if x.Payment == nil {
			return nil
		}
		switch x.Payment.(type) {
		case *Customer3_CreditCardNo:
			return x.Descriptor().Fields().ByName("credit_card_no")
		case *Customer3_ChequeNo:
			return x.Descriptor().Fields().ByName("cheque_no")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.Customer3", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_Customer3) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_Customer3) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_Customer3) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_Customer3) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*Customer3)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Sf != 0 || math.Signbit(float64(x.Sf)) {
			n += 5
		}
		if x.Surcharge != 0 || math.Signbit(float64(x.Surcharge)) {
			n += 5
		}
		l = len(x.Destination)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		switch x := x.Payment.(type) {
		case *Customer3_CreditCardNo:
			if x == nil {
				break
			}
			l = len(x.CreditCardNo)
			n += 1 + l + runtime.Sov(uint64(l))
		case *Customer3_ChequeNo:
			if x == nil {
				break
			}
			l = len(x.ChequeNo)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Original != nil {
			l = options.Size(x.Original)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*Customer3)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Payment.(type) {
		case *Customer3_CreditCardNo:
			i -= len(x.CreditCardNo)
			copy(dAtA[i:], x.CreditCardNo)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.CreditCardNo)))
			i--
			dAtA[i] = 0x3a
		case *Customer3_ChequeNo:
			i -= len(x.ChequeNo)
			copy(dAtA[i:], x.ChequeNo)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ChequeNo)))
			i--
			dAtA[i] = 0x42
		}
		if x.Original != nil {
			encoded, err := options.Marshal(x.Original)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x4a
		}
		if len(x.Destination) > 0 {
			i -= len(x.Destination)
			copy(dAtA[i:], x.Destination)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Destination)))
			i--
			dAtA[i] = 0x2a
		}
		if x.Surcharge != 0 || math.Signbit(float64(x.Surcharge)) {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.Surcharge))))
			i--
			dAtA[i] = 0x25
		}
		if x.Sf != 0 || math.Signbit(float64(x.Sf)) {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(x.Sf))))
			i--
			dAtA[i] = 0x1d
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*Customer3)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer3: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: Customer3: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 5 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Sf", wireType)
				}
				var v uint32
				if (iNdEx + 4) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				x.Sf = float32(math.Float32frombits(v))
			case 4:
				if wireType != 5 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Surcharge", wireType)
				}
				var v uint32
				if (iNdEx + 4) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				x.Surcharge = float32(math.Float32frombits(v))
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Destination", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Destination = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field CreditCardNo", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Payment = &Customer3_CreditCardNo{string(dAtA[iNdEx:postIndex])}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ChequeNo", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Payment = &Customer3_ChequeNo{string(dAtA[iNdEx:postIndex])}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Original", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Original == nil {
					x.Original = &Customer1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Original); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersion1_4_list)(nil)

type _TestVersion1_4_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion1_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion1_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion1_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion1_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion1_4_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion1_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion1_4_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion1_4_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion1_5_list)(nil)

type _TestVersion1_5_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion1_5_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion1_5_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion1_5_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion1_5_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion1_5_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion1_5_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion1_5_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion1_5_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion1_9_list)(nil)

type _TestVersion1_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion1_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion1_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion1_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion1_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion1_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion1_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion1_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion1_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersion1   protoreflect.MessageDescriptor
	fd_TestVersion1_x protoreflect.FieldDescriptor
	fd_TestVersion1_a protoreflect.FieldDescriptor
	fd_TestVersion1_b protoreflect.FieldDescriptor
	fd_TestVersion1_c protoreflect.FieldDescriptor
	fd_TestVersion1_d protoreflect.FieldDescriptor
	fd_TestVersion1_e protoreflect.FieldDescriptor
	fd_TestVersion1_f protoreflect.FieldDescriptor
	fd_TestVersion1_g protoreflect.FieldDescriptor
	fd_TestVersion1_h protoreflect.FieldDescriptor
	fd_TestVersion1_k protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion1 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion1")
	fd_TestVersion1_x = md_TestVersion1.Fields().ByName("x")
	fd_TestVersion1_a = md_TestVersion1.Fields().ByName("a")
	fd_TestVersion1_b = md_TestVersion1.Fields().ByName("b")
	fd_TestVersion1_c = md_TestVersion1.Fields().ByName("c")
	fd_TestVersion1_d = md_TestVersion1.Fields().ByName("d")
	fd_TestVersion1_e = md_TestVersion1.Fields().ByName("e")
	fd_TestVersion1_f = md_TestVersion1.Fields().ByName("f")
	fd_TestVersion1_g = md_TestVersion1.Fields().ByName("g")
	fd_TestVersion1_h = md_TestVersion1.Fields().ByName("h")
	fd_TestVersion1_k = md_TestVersion1.Fields().ByName("k")
}

var _ protoreflect.Message = (*fastReflection_TestVersion1)(nil)

type fastReflection_TestVersion1 TestVersion1

func (x *TestVersion1) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion1)(x)
}

func (x *TestVersion1) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[11]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion1_messageType fastReflection_TestVersion1_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion1_messageType{}

type fastReflection_TestVersion1_messageType struct{}

func (x fastReflection_TestVersion1_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion1)(nil)
}
func (x fastReflection_TestVersion1_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion1)
}
func (x fastReflection_TestVersion1_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion1
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion1) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion1
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion1) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion1_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion1) New() protoreflect.Message {
	return new(fastReflection_TestVersion1)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion1) Interface() protoreflect.ProtoMessage {
	return (*TestVersion1)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersion1_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersion1_a, value) {
			return
		}
	}
	if x.B != nil {
		value := protoreflect.ValueOfMessage(x.B.ProtoReflect())
		if !f(fd_TestVersion1_b, value) {
			return
		}
	}
	if len(x.C) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion1_4_list{list: &x.C})
		if !f(fd_TestVersion1_c, value) {
			return
		}
	}
	if len(x.D) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion1_5_list{list: &x.D})
		if !f(fd_TestVersion1_d, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersion1_E:
			v := o.E
			value := protoreflect.ValueOfInt32(v)
			if !f(fd_TestVersion1_e, value) {
				return
			}
		case *TestVersion1_F:
			v := o.F
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_TestVersion1_f, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersion1_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion1_9_list{list: &x.H})
		if !f(fd_TestVersion1_h, value) {
			return
		}
	}
	if x.K != nil {
		value := protoreflect.ValueOfMessage(x.K.ProtoReflect())
		if !f(fd_TestVersion1_k, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion1) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion1.x":
		return x.X != int64(0)
	case "testpb.TestVersion1.a":
		return x.A != nil
	case "testpb.TestVersion1.b":
		return x.B != nil
	case "testpb.TestVersion1.c":
		return len(x.C) != 0
	case "testpb.TestVersion1.d":
		return len(x.D) != 0
	case "testpb.TestVersion1.e":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion1_E); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion1.f":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion1_F); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion1.g":
		return x.G != nil
	case "testpb.TestVersion1.h":
		return len(x.H) != 0
	case "testpb.TestVersion1.k":
		return x.K != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion1) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion1.x":
		x.X = int64(0)
	case "testpb.TestVersion1.a":
		x.A = nil
	case "testpb.TestVersion1.b":
		x.B = nil
	case "testpb.TestVersion1.c":
		x.C = nil
	case "testpb.TestVersion1.d":
		x.D = nil
	case "testpb.TestVersion1.e":
		x.Sum = nil
	case "testpb.TestVersion1.f":
		x.Sum = nil
	case "testpb.TestVersion1.g":
		x.G = nil
	case "testpb.TestVersion1.h":
		x.H = nil
	case "testpb.TestVersion1.k":
		x.K = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion1.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion1.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion1.b":
		value := x.B
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion1.c":
		if len(x.C) == 0 {
			return protoreflect.ValueOfList(&_TestVersion1_4_list{})
		}
		listValue := &_TestVersion1_4_list{list: &x.C}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion1.d":
		if len(x.D) == 0 {
			return protoreflect.ValueOfList(&_TestVersion1_5_list{})
		}
		listValue := &_TestVersion1_5_list{list: &x.D}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion1.e":
		if x.Sum == nil {
			return protoreflect.ValueOfInt32(int32(0))
		} else if v, ok := x.Sum.(*TestVersion1_E); ok {
			return protoreflect.ValueOfInt32(v.E)
		} else {
			return protoreflect.ValueOfInt32(int32(0))
		}
	case "testpb.TestVersion1.f":
		if x.Sum == nil {
			return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect())
		} else if v, ok := x.Sum.(*TestVersion1_F); ok {
			return protoreflect.ValueOfMessage(v.F.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect())
		}
	case "testpb.TestVersion1.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion1.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersion1_9_list{})
		}
		listValue := &_TestVersion1_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion1.k":
		value := x.K
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion1.x":
		x.X = value.Int()
	case "testpb.TestVersion1.a":
		x.A = value.Message().Interface().(*TestVersion1)
	case "testpb.TestVersion1.b":
		x.B = value.Message().Interface().(*TestVersion1)
	case "testpb.TestVersion1.c":
		lv := value.List()
		clv := lv.(*_TestVersion1_4_list)
		x.C = *clv.list
	case "testpb.TestVersion1.d":
		lv := value.List()
		clv := lv.(*_TestVersion1_5_list)
		x.D = *clv.list
	case "testpb.TestVersion1.e":
		cv := int32(value.Int())
		x.Sum = &TestVersion1_E{E: cv}
	case "testpb.TestVersion1.f":
		cv := value.Message().Interface().(*TestVersion1)
		x.Sum = &TestVersion1_F{F: cv}
	case "testpb.TestVersion1.g":
		x.G = value.Message().Interface().(*anypb.Any)
	case "testpb.TestVersion1.h":
		lv := value.List()
		clv := lv.(*_TestVersion1_9_list)
		x.H = *clv.list
	case "testpb.TestVersion1.k":
		x.K = value.Message().Interface().(*Customer1)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion1.a":
		if x.A == nil {
			x.A = new(TestVersion1)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersion1.b":
		if x.B == nil {
			x.B = new(TestVersion1)
		}
		return protoreflect.ValueOfMessage(x.B.ProtoReflect())
	case "testpb.TestVersion1.c":
		if x.C == nil {
			x.C = []*TestVersion1{}
		}
		value := &_TestVersion1_4_list{list: &x.C}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion1.d":
		if x.D == nil {
			x.D = []*TestVersion1{}
		}
		value := &_TestVersion1_5_list{list: &x.D}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion1.f":
		if x.Sum == nil {
			value := &TestVersion1{}
			oneofValue := &TestVersion1_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Sum.(type) {
		case *TestVersion1_F:
			return protoreflect.ValueOfMessage(m.F.ProtoReflect())
		default:
			value := &TestVersion1{}
			oneofValue := &TestVersion1_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "testpb.TestVersion1.g":
		if x.G == nil {
			x.G = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersion1.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersion1_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion1.k":
		if x.K == nil {
			x.K = new(Customer1)
		}
		return protoreflect.ValueOfMessage(x.K.ProtoReflect())
	case "testpb.TestVersion1.x":
		panic(fmt.Errorf("field x of message testpb.TestVersion1 is not mutable"))
	case "testpb.TestVersion1.e":
		panic(fmt.Errorf("field e of message testpb.TestVersion1 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion1.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion1.a":
		m := new(TestVersion1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion1.b":
		m := new(TestVersion1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion1.c":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion1_4_list{list: &list})
	case "testpb.TestVersion1.d":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion1_5_list{list: &list})
	case "testpb.TestVersion1.e":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.TestVersion1.f":
		value := &TestVersion1{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion1.g":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion1.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion1_9_list{list: &list})
	case "testpb.TestVersion1.k":
		m := new(Customer1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion1 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersion1.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersion1_E:
			return x.Descriptor().Fields().ByName("e")
		case *TestVersion1_F:
			return x.Descriptor().Fields().ByName("f")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion1", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion1) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion1) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion1) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion1) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion1)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.B != nil {
			l = options.Size(x.B)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.C) > 0 {
			for _, e := range x.C {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.D) > 0 {
			for _, e := range x.D {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		switch x := x.Sum.(type) {
		case *TestVersion1_E:
			if x == nil {
				break
			}
			n += 1 + runtime.Sov(uint64(x.E))
		case *TestVersion1_F:
			if x == nil {
				break
			}
			l = options.Size(x.F)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.K != nil {
			l = options.Size(x.K)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion1)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersion1_E:
			i = runtime.EncodeVarint(dAtA, i, uint64(x.E))
			i--
			dAtA[i] = 0x30
		case *TestVersion1_F:
			encoded, err := options.Marshal(x.F)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x3a
		}
		if x.K != nil {
			encoded, err := options.Marshal(x.K)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x62
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.D) > 0 {
			for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.D[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x2a
			}
		}
		if len(x.C) > 0 {
			for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.C[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if x.B != nil {
			encoded, err := options.Marshal(x.B)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion1)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion1: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion1: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.B == nil {
					x.B = &TestVersion1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.C = append(x.C, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.D = append(x.D, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 6:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType)
				}
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Sum = &TestVersion1_E{v}
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v := &TestVersion1{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Sum = &TestVersion1_F{v}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 12:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.K == nil {
					x.K = &Customer1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersion2_4_list)(nil)

type _TestVersion2_4_list struct {
	list *[]*TestVersion2
}

func (x *_TestVersion2_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion2_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion2_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion2)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion2_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion2)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion2_4_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion2)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion2_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion2_4_list) NewElement() protoreflect.Value {
	v := new(TestVersion2)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion2_4_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion2_5_list)(nil)

type _TestVersion2_5_list struct {
	list *[]*TestVersion2
}

func (x *_TestVersion2_5_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion2_5_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion2_5_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion2)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion2_5_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion2)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion2_5_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion2)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion2_5_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion2_5_list) NewElement() protoreflect.Value {
	v := new(TestVersion2)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion2_5_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion2_9_list)(nil)

type _TestVersion2_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion2_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion2_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion2_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion2_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion2_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion2_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion2_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion2_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersion2           protoreflect.MessageDescriptor
	fd_TestVersion2_x         protoreflect.FieldDescriptor
	fd_TestVersion2_a         protoreflect.FieldDescriptor
	fd_TestVersion2_b         protoreflect.FieldDescriptor
	fd_TestVersion2_c         protoreflect.FieldDescriptor
	fd_TestVersion2_d         protoreflect.FieldDescriptor
	fd_TestVersion2_e         protoreflect.FieldDescriptor
	fd_TestVersion2_f         protoreflect.FieldDescriptor
	fd_TestVersion2_g         protoreflect.FieldDescriptor
	fd_TestVersion2_h         protoreflect.FieldDescriptor
	fd_TestVersion2_k         protoreflect.FieldDescriptor
	fd_TestVersion2_new_field protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion2 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion2")
	fd_TestVersion2_x = md_TestVersion2.Fields().ByName("x")
	fd_TestVersion2_a = md_TestVersion2.Fields().ByName("a")
	fd_TestVersion2_b = md_TestVersion2.Fields().ByName("b")
	fd_TestVersion2_c = md_TestVersion2.Fields().ByName("c")
	fd_TestVersion2_d = md_TestVersion2.Fields().ByName("d")
	fd_TestVersion2_e = md_TestVersion2.Fields().ByName("e")
	fd_TestVersion2_f = md_TestVersion2.Fields().ByName("f")
	fd_TestVersion2_g = md_TestVersion2.Fields().ByName("g")
	fd_TestVersion2_h = md_TestVersion2.Fields().ByName("h")
	fd_TestVersion2_k = md_TestVersion2.Fields().ByName("k")
	fd_TestVersion2_new_field = md_TestVersion2.Fields().ByName("new_field")
}

var _ protoreflect.Message = (*fastReflection_TestVersion2)(nil)

type fastReflection_TestVersion2 TestVersion2

func (x *TestVersion2) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion2)(x)
}

func (x *TestVersion2) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[12]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion2_messageType fastReflection_TestVersion2_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion2_messageType{}

type fastReflection_TestVersion2_messageType struct{}

func (x fastReflection_TestVersion2_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion2)(nil)
}
func (x fastReflection_TestVersion2_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion2)
}
func (x fastReflection_TestVersion2_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion2
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion2) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion2
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion2) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion2_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion2) New() protoreflect.Message {
	return new(fastReflection_TestVersion2)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion2) Interface() protoreflect.ProtoMessage {
	return (*TestVersion2)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersion2_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersion2_a, value) {
			return
		}
	}
	if x.B != nil {
		value := protoreflect.ValueOfMessage(x.B.ProtoReflect())
		if !f(fd_TestVersion2_b, value) {
			return
		}
	}
	if len(x.C) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion2_4_list{list: &x.C})
		if !f(fd_TestVersion2_c, value) {
			return
		}
	}
	if len(x.D) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion2_5_list{list: &x.D})
		if !f(fd_TestVersion2_d, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersion2_E:
			v := o.E
			value := protoreflect.ValueOfInt32(v)
			if !f(fd_TestVersion2_e, value) {
				return
			}
		case *TestVersion2_F:
			v := o.F
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_TestVersion2_f, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersion2_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion2_9_list{list: &x.H})
		if !f(fd_TestVersion2_h, value) {
			return
		}
	}
	if x.K != nil {
		value := protoreflect.ValueOfMessage(x.K.ProtoReflect())
		if !f(fd_TestVersion2_k, value) {
			return
		}
	}
	if x.NewField_ != uint64(0) {
		value := protoreflect.ValueOfUint64(x.NewField_)
		if !f(fd_TestVersion2_new_field, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion2) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion2.x":
		return x.X != int64(0)
	case "testpb.TestVersion2.a":
		return x.A != nil
	case "testpb.TestVersion2.b":
		return x.B != nil
	case "testpb.TestVersion2.c":
		return len(x.C) != 0
	case "testpb.TestVersion2.d":
		return len(x.D) != 0
	case "testpb.TestVersion2.e":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion2_E); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion2.f":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion2_F); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion2.g":
		return x.G != nil
	case "testpb.TestVersion2.h":
		return len(x.H) != 0
	case "testpb.TestVersion2.k":
		return x.K != nil
	case "testpb.TestVersion2.new_field":
		return x.NewField_ != uint64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion2) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion2.x":
		x.X = int64(0)
	case "testpb.TestVersion2.a":
		x.A = nil
	case "testpb.TestVersion2.b":
		x.B = nil
	case "testpb.TestVersion2.c":
		x.C = nil
	case "testpb.TestVersion2.d":
		x.D = nil
	case "testpb.TestVersion2.e":
		x.Sum = nil
	case "testpb.TestVersion2.f":
		x.Sum = nil
	case "testpb.TestVersion2.g":
		x.G = nil
	case "testpb.TestVersion2.h":
		x.H = nil
	case "testpb.TestVersion2.k":
		x.K = nil
	case "testpb.TestVersion2.new_field":
		x.NewField_ = uint64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion2.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion2.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion2.b":
		value := x.B
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion2.c":
		if len(x.C) == 0 {
			return protoreflect.ValueOfList(&_TestVersion2_4_list{})
		}
		listValue := &_TestVersion2_4_list{list: &x.C}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion2.d":
		if len(x.D) == 0 {
			return protoreflect.ValueOfList(&_TestVersion2_5_list{})
		}
		listValue := &_TestVersion2_5_list{list: &x.D}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion2.e":
		if x.Sum == nil {
			return protoreflect.ValueOfInt32(int32(0))
		} else if v, ok := x.Sum.(*TestVersion2_E); ok {
			return protoreflect.ValueOfInt32(v.E)
		} else {
			return protoreflect.ValueOfInt32(int32(0))
		}
	case "testpb.TestVersion2.f":
		if x.Sum == nil {
			return protoreflect.ValueOfMessage((*TestVersion2)(nil).ProtoReflect())
		} else if v, ok := x.Sum.(*TestVersion2_F); ok {
			return protoreflect.ValueOfMessage(v.F.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*TestVersion2)(nil).ProtoReflect())
		}
	case "testpb.TestVersion2.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion2.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersion2_9_list{})
		}
		listValue := &_TestVersion2_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion2.k":
		value := x.K
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion2.new_field":
		value := x.NewField_
		return protoreflect.ValueOfUint64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion2.x":
		x.X = value.Int()
	case "testpb.TestVersion2.a":
		x.A = value.Message().Interface().(*TestVersion2)
	case "testpb.TestVersion2.b":
		x.B = value.Message().Interface().(*TestVersion2)
	case "testpb.TestVersion2.c":
		lv := value.List()
		clv := lv.(*_TestVersion2_4_list)
		x.C = *clv.list
	case "testpb.TestVersion2.d":
		lv := value.List()
		clv := lv.(*_TestVersion2_5_list)
		x.D = *clv.list
	case "testpb.TestVersion2.e":
		cv := int32(value.Int())
		x.Sum = &TestVersion2_E{E: cv}
	case "testpb.TestVersion2.f":
		cv := value.Message().Interface().(*TestVersion2)
		x.Sum = &TestVersion2_F{F: cv}
	case "testpb.TestVersion2.g":
		x.G = value.Message().Interface().(*anypb.Any)
	case "testpb.TestVersion2.h":
		lv := value.List()
		clv := lv.(*_TestVersion2_9_list)
		x.H = *clv.list
	case "testpb.TestVersion2.k":
		x.K = value.Message().Interface().(*Customer1)
	case "testpb.TestVersion2.new_field":
		x.NewField_ = value.Uint()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion2.a":
		if x.A == nil {
			x.A = new(TestVersion2)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersion2.b":
		if x.B == nil {
			x.B = new(TestVersion2)
		}
		return protoreflect.ValueOfMessage(x.B.ProtoReflect())
	case "testpb.TestVersion2.c":
		if x.C == nil {
			x.C = []*TestVersion2{}
		}
		value := &_TestVersion2_4_list{list: &x.C}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion2.d":
		if x.D == nil {
			x.D = []*TestVersion2{}
		}
		value := &_TestVersion2_5_list{list: &x.D}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion2.f":
		if x.Sum == nil {
			value := &TestVersion2{}
			oneofValue := &TestVersion2_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Sum.(type) {
		case *TestVersion2_F:
			return protoreflect.ValueOfMessage(m.F.ProtoReflect())
		default:
			value := &TestVersion2{}
			oneofValue := &TestVersion2_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "testpb.TestVersion2.g":
		if x.G == nil {
			x.G = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersion2.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersion2_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion2.k":
		if x.K == nil {
			x.K = new(Customer1)
		}
		return protoreflect.ValueOfMessage(x.K.ProtoReflect())
	case "testpb.TestVersion2.x":
		panic(fmt.Errorf("field x of message testpb.TestVersion2 is not mutable"))
	case "testpb.TestVersion2.e":
		panic(fmt.Errorf("field e of message testpb.TestVersion2 is not mutable"))
	case "testpb.TestVersion2.new_field":
		panic(fmt.Errorf("field new_field of message testpb.TestVersion2 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion2.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion2.a":
		m := new(TestVersion2)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion2.b":
		m := new(TestVersion2)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion2.c":
		list := []*TestVersion2{}
		return protoreflect.ValueOfList(&_TestVersion2_4_list{list: &list})
	case "testpb.TestVersion2.d":
		list := []*TestVersion2{}
		return protoreflect.ValueOfList(&_TestVersion2_5_list{list: &list})
	case "testpb.TestVersion2.e":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.TestVersion2.f":
		value := &TestVersion2{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion2.g":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion2.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion2_9_list{list: &list})
	case "testpb.TestVersion2.k":
		m := new(Customer1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion2.new_field":
		return protoreflect.ValueOfUint64(uint64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion2 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersion2.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersion2_E:
			return x.Descriptor().Fields().ByName("e")
		case *TestVersion2_F:
			return x.Descriptor().Fields().ByName("f")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion2", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion2) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion2) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion2) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion2) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion2)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.B != nil {
			l = options.Size(x.B)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.C) > 0 {
			for _, e := range x.C {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.D) > 0 {
			for _, e := range x.D {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		switch x := x.Sum.(type) {
		case *TestVersion2_E:
			if x == nil {
				break
			}
			n += 1 + runtime.Sov(uint64(x.E))
		case *TestVersion2_F:
			if x == nil {
				break
			}
			l = options.Size(x.F)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.K != nil {
			l = options.Size(x.K)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.NewField_ != 0 {
			n += 2 + runtime.Sov(uint64(x.NewField_))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion2)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersion2_E:
			i = runtime.EncodeVarint(dAtA, i, uint64(x.E))
			i--
			dAtA[i] = 0x30
		case *TestVersion2_F:
			encoded, err := options.Marshal(x.F)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x3a
		}
		if x.NewField_ != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.NewField_))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc8
		}
		if x.K != nil {
			encoded, err := options.Marshal(x.K)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x62
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.D) > 0 {
			for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.D[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x2a
			}
		}
		if len(x.C) > 0 {
			for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.C[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if x.B != nil {
			encoded, err := options.Marshal(x.B)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion2)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion2: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion2: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion2{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.B == nil {
					x.B = &TestVersion2{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.C = append(x.C, &TestVersion2{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.D = append(x.D, &TestVersion2{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 6:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType)
				}
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Sum = &TestVersion2_E{v}
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v := &TestVersion2{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Sum = &TestVersion2_F{v}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 12:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.K == nil {
					x.K = &Customer1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_", wireType)
				}
				x.NewField_ = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.NewField_ |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersion3_4_list)(nil)

type _TestVersion3_4_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion3_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3_4_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3_4_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3_4_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion3_5_list)(nil)

type _TestVersion3_5_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion3_5_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3_5_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3_5_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3_5_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3_5_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3_5_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3_5_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3_5_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion3_9_list)(nil)

type _TestVersion3_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion3_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersion3                    protoreflect.MessageDescriptor
	fd_TestVersion3_x                  protoreflect.FieldDescriptor
	fd_TestVersion3_a                  protoreflect.FieldDescriptor
	fd_TestVersion3_b                  protoreflect.FieldDescriptor
	fd_TestVersion3_c                  protoreflect.FieldDescriptor
	fd_TestVersion3_d                  protoreflect.FieldDescriptor
	fd_TestVersion3_e                  protoreflect.FieldDescriptor
	fd_TestVersion3_f                  protoreflect.FieldDescriptor
	fd_TestVersion3_g                  protoreflect.FieldDescriptor
	fd_TestVersion3_h                  protoreflect.FieldDescriptor
	fd_TestVersion3_k                  protoreflect.FieldDescriptor
	fd_TestVersion3_non_critical_field protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion3 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion3")
	fd_TestVersion3_x = md_TestVersion3.Fields().ByName("x")
	fd_TestVersion3_a = md_TestVersion3.Fields().ByName("a")
	fd_TestVersion3_b = md_TestVersion3.Fields().ByName("b")
	fd_TestVersion3_c = md_TestVersion3.Fields().ByName("c")
	fd_TestVersion3_d = md_TestVersion3.Fields().ByName("d")
	fd_TestVersion3_e = md_TestVersion3.Fields().ByName("e")
	fd_TestVersion3_f = md_TestVersion3.Fields().ByName("f")
	fd_TestVersion3_g = md_TestVersion3.Fields().ByName("g")
	fd_TestVersion3_h = md_TestVersion3.Fields().ByName("h")
	fd_TestVersion3_k = md_TestVersion3.Fields().ByName("k")
	fd_TestVersion3_non_critical_field = md_TestVersion3.Fields().ByName("non_critical_field")
}

var _ protoreflect.Message = (*fastReflection_TestVersion3)(nil)

type fastReflection_TestVersion3 TestVersion3

func (x *TestVersion3) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion3)(x)
}

func (x *TestVersion3) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[13]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion3_messageType fastReflection_TestVersion3_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion3_messageType{}

type fastReflection_TestVersion3_messageType struct{}

func (x fastReflection_TestVersion3_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion3)(nil)
}
func (x fastReflection_TestVersion3_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion3)
}
func (x fastReflection_TestVersion3_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion3) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion3) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion3_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion3) New() protoreflect.Message {
	return new(fastReflection_TestVersion3)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion3) Interface() protoreflect.ProtoMessage {
	return (*TestVersion3)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion3) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersion3_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersion3_a, value) {
			return
		}
	}
	if x.B != nil {
		value := protoreflect.ValueOfMessage(x.B.ProtoReflect())
		if !f(fd_TestVersion3_b, value) {
			return
		}
	}
	if len(x.C) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3_4_list{list: &x.C})
		if !f(fd_TestVersion3_c, value) {
			return
		}
	}
	if len(x.D) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3_5_list{list: &x.D})
		if !f(fd_TestVersion3_d, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersion3_E:
			v := o.E
			value := protoreflect.ValueOfInt32(v)
			if !f(fd_TestVersion3_e, value) {
				return
			}
		case *TestVersion3_F:
			v := o.F
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_TestVersion3_f, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersion3_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3_9_list{list: &x.H})
		if !f(fd_TestVersion3_h, value) {
			return
		}
	}
	if x.K != nil {
		value := protoreflect.ValueOfMessage(x.K.ProtoReflect())
		if !f(fd_TestVersion3_k, value) {
			return
		}
	}
	if x.NonCriticalField != "" {
		value := protoreflect.ValueOfString(x.NonCriticalField)
		if !f(fd_TestVersion3_non_critical_field, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion3) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion3.x":
		return x.X != int64(0)
	case "testpb.TestVersion3.a":
		return x.A != nil
	case "testpb.TestVersion3.b":
		return x.B != nil
	case "testpb.TestVersion3.c":
		return len(x.C) != 0
	case "testpb.TestVersion3.d":
		return len(x.D) != 0
	case "testpb.TestVersion3.e":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion3_E); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion3.f":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion3_F); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion3.g":
		return x.G != nil
	case "testpb.TestVersion3.h":
		return len(x.H) != 0
	case "testpb.TestVersion3.k":
		return x.K != nil
	case "testpb.TestVersion3.non_critical_field":
		return x.NonCriticalField != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion3.x":
		x.X = int64(0)
	case "testpb.TestVersion3.a":
		x.A = nil
	case "testpb.TestVersion3.b":
		x.B = nil
	case "testpb.TestVersion3.c":
		x.C = nil
	case "testpb.TestVersion3.d":
		x.D = nil
	case "testpb.TestVersion3.e":
		x.Sum = nil
	case "testpb.TestVersion3.f":
		x.Sum = nil
	case "testpb.TestVersion3.g":
		x.G = nil
	case "testpb.TestVersion3.h":
		x.H = nil
	case "testpb.TestVersion3.k":
		x.K = nil
	case "testpb.TestVersion3.non_critical_field":
		x.NonCriticalField = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion3) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion3.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion3.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3.b":
		value := x.B
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3.c":
		if len(x.C) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3_4_list{})
		}
		listValue := &_TestVersion3_4_list{list: &x.C}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3.d":
		if len(x.D) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3_5_list{})
		}
		listValue := &_TestVersion3_5_list{list: &x.D}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3.e":
		if x.Sum == nil {
			return protoreflect.ValueOfInt32(int32(0))
		} else if v, ok := x.Sum.(*TestVersion3_E); ok {
			return protoreflect.ValueOfInt32(v.E)
		} else {
			return protoreflect.ValueOfInt32(int32(0))
		}
	case "testpb.TestVersion3.f":
		if x.Sum == nil {
			return protoreflect.ValueOfMessage((*TestVersion3)(nil).ProtoReflect())
		} else if v, ok := x.Sum.(*TestVersion3_F); ok {
			return protoreflect.ValueOfMessage(v.F.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*TestVersion3)(nil).ProtoReflect())
		}
	case "testpb.TestVersion3.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3_9_list{})
		}
		listValue := &_TestVersion3_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3.k":
		value := x.K
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3.non_critical_field":
		value := x.NonCriticalField
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion3.x":
		x.X = value.Int()
	case "testpb.TestVersion3.a":
		x.A = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion3.b":
		x.B = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion3.c":
		lv := value.List()
		clv := lv.(*_TestVersion3_4_list)
		x.C = *clv.list
	case "testpb.TestVersion3.d":
		lv := value.List()
		clv := lv.(*_TestVersion3_5_list)
		x.D = *clv.list
	case "testpb.TestVersion3.e":
		cv := int32(value.Int())
		x.Sum = &TestVersion3_E{E: cv}
	case "testpb.TestVersion3.f":
		cv := value.Message().Interface().(*TestVersion3)
		x.Sum = &TestVersion3_F{F: cv}
	case "testpb.TestVersion3.g":
		x.G = value.Message().Interface().(*anypb.Any)
	case "testpb.TestVersion3.h":
		lv := value.List()
		clv := lv.(*_TestVersion3_9_list)
		x.H = *clv.list
	case "testpb.TestVersion3.k":
		x.K = value.Message().Interface().(*Customer1)
	case "testpb.TestVersion3.non_critical_field":
		x.NonCriticalField = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3.a":
		if x.A == nil {
			x.A = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersion3.b":
		if x.B == nil {
			x.B = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.B.ProtoReflect())
	case "testpb.TestVersion3.c":
		if x.C == nil {
			x.C = []*TestVersion3{}
		}
		value := &_TestVersion3_4_list{list: &x.C}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3.d":
		if x.D == nil {
			x.D = []*TestVersion3{}
		}
		value := &_TestVersion3_5_list{list: &x.D}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3.f":
		if x.Sum == nil {
			value := &TestVersion3{}
			oneofValue := &TestVersion3_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Sum.(type) {
		case *TestVersion3_F:
			return protoreflect.ValueOfMessage(m.F.ProtoReflect())
		default:
			value := &TestVersion3{}
			oneofValue := &TestVersion3_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "testpb.TestVersion3.g":
		if x.G == nil {
			x.G = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersion3.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersion3_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3.k":
		if x.K == nil {
			x.K = new(Customer1)
		}
		return protoreflect.ValueOfMessage(x.K.ProtoReflect())
	case "testpb.TestVersion3.x":
		panic(fmt.Errorf("field x of message testpb.TestVersion3 is not mutable"))
	case "testpb.TestVersion3.e":
		panic(fmt.Errorf("field e of message testpb.TestVersion3 is not mutable"))
	case "testpb.TestVersion3.non_critical_field":
		panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion3 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion3) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion3.a":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3.b":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3.c":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion3_4_list{list: &list})
	case "testpb.TestVersion3.d":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion3_5_list{list: &list})
	case "testpb.TestVersion3.e":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.TestVersion3.f":
		value := &TestVersion3{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3.g":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion3_9_list{list: &list})
	case "testpb.TestVersion3.k":
		m := new(Customer1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3.non_critical_field":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion3) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersion3.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersion3_E:
			return x.Descriptor().Fields().ByName("e")
		case *TestVersion3_F:
			return x.Descriptor().Fields().ByName("f")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion3) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion3) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion3) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion3)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.B != nil {
			l = options.Size(x.B)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.C) > 0 {
			for _, e := range x.C {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.D) > 0 {
			for _, e := range x.D {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		switch x := x.Sum.(type) {
		case *TestVersion3_E:
			if x == nil {
				break
			}
			n += 1 + runtime.Sov(uint64(x.E))
		case *TestVersion3_F:
			if x == nil {
				break
			}
			l = options.Size(x.F)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.K != nil {
			l = options.Size(x.K)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.NonCriticalField)
		if l > 0 {
			n += 2 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersion3_E:
			i = runtime.EncodeVarint(dAtA, i, uint64(x.E))
			i--
			dAtA[i] = 0x30
		case *TestVersion3_F:
			encoded, err := options.Marshal(x.F)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.NonCriticalField) > 0 {
			i -= len(x.NonCriticalField)
			copy(dAtA[i:], x.NonCriticalField)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField)))
			i--
			dAtA[i] = 0x40
			i--
			dAtA[i] = 0xba
		}
		if x.K != nil {
			encoded, err := options.Marshal(x.K)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x62
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.D) > 0 {
			for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.D[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x2a
			}
		}
		if len(x.C) > 0 {
			for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.C[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if x.B != nil {
			encoded, err := options.Marshal(x.B)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.B == nil {
					x.B = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.C = append(x.C, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.D = append(x.D, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 6:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType)
				}
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Sum = &TestVersion3_E{v}
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v := &TestVersion3{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Sum = &TestVersion3_F{v}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 12:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.K == nil {
					x.K = &Customer1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 1031:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NonCriticalField = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersion3LoneOneOfValue_4_list)(nil)

type _TestVersion3LoneOneOfValue_4_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion3LoneOneOfValue_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3LoneOneOfValue_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3LoneOneOfValue_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3LoneOneOfValue_4_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3LoneOneOfValue_4_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_4_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion3LoneOneOfValue_5_list)(nil)

type _TestVersion3LoneOneOfValue_5_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion3LoneOneOfValue_5_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3LoneOneOfValue_5_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_5_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3LoneOneOfValue_5_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3LoneOneOfValue_5_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_5_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3LoneOneOfValue_5_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_5_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion3LoneOneOfValue_9_list)(nil)

type _TestVersion3LoneOneOfValue_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion3LoneOneOfValue_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3LoneOneOfValue_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3LoneOneOfValue_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3LoneOneOfValue_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3LoneOneOfValue_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneOneOfValue_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersion3LoneOneOfValue                    protoreflect.MessageDescriptor
	fd_TestVersion3LoneOneOfValue_x                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_a                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_b                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_c                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_d                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_e                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_g                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_h                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_k                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneOneOfValue_non_critical_field protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion3LoneOneOfValue = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion3LoneOneOfValue")
	fd_TestVersion3LoneOneOfValue_x = md_TestVersion3LoneOneOfValue.Fields().ByName("x")
	fd_TestVersion3LoneOneOfValue_a = md_TestVersion3LoneOneOfValue.Fields().ByName("a")
	fd_TestVersion3LoneOneOfValue_b = md_TestVersion3LoneOneOfValue.Fields().ByName("b")
	fd_TestVersion3LoneOneOfValue_c = md_TestVersion3LoneOneOfValue.Fields().ByName("c")
	fd_TestVersion3LoneOneOfValue_d = md_TestVersion3LoneOneOfValue.Fields().ByName("d")
	fd_TestVersion3LoneOneOfValue_e = md_TestVersion3LoneOneOfValue.Fields().ByName("e")
	fd_TestVersion3LoneOneOfValue_g = md_TestVersion3LoneOneOfValue.Fields().ByName("g")
	fd_TestVersion3LoneOneOfValue_h = md_TestVersion3LoneOneOfValue.Fields().ByName("h")
	fd_TestVersion3LoneOneOfValue_k = md_TestVersion3LoneOneOfValue.Fields().ByName("k")
	fd_TestVersion3LoneOneOfValue_non_critical_field = md_TestVersion3LoneOneOfValue.Fields().ByName("non_critical_field")
}

var _ protoreflect.Message = (*fastReflection_TestVersion3LoneOneOfValue)(nil)

type fastReflection_TestVersion3LoneOneOfValue TestVersion3LoneOneOfValue

func (x *TestVersion3LoneOneOfValue) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneOneOfValue)(x)
}

func (x *TestVersion3LoneOneOfValue) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[14]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion3LoneOneOfValue_messageType fastReflection_TestVersion3LoneOneOfValue_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion3LoneOneOfValue_messageType{}

type fastReflection_TestVersion3LoneOneOfValue_messageType struct{}

func (x fastReflection_TestVersion3LoneOneOfValue_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneOneOfValue)(nil)
}
func (x fastReflection_TestVersion3LoneOneOfValue_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneOneOfValue)
}
func (x fastReflection_TestVersion3LoneOneOfValue_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneOneOfValue
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion3LoneOneOfValue) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneOneOfValue
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion3LoneOneOfValue) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion3LoneOneOfValue_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion3LoneOneOfValue) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneOneOfValue)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion3LoneOneOfValue) Interface() protoreflect.ProtoMessage {
	return (*TestVersion3LoneOneOfValue)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion3LoneOneOfValue) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersion3LoneOneOfValue_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersion3LoneOneOfValue_a, value) {
			return
		}
	}
	if x.B != nil {
		value := protoreflect.ValueOfMessage(x.B.ProtoReflect())
		if !f(fd_TestVersion3LoneOneOfValue_b, value) {
			return
		}
	}
	if len(x.C) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_4_list{list: &x.C})
		if !f(fd_TestVersion3LoneOneOfValue_c, value) {
			return
		}
	}
	if len(x.D) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_5_list{list: &x.D})
		if !f(fd_TestVersion3LoneOneOfValue_d, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersion3LoneOneOfValue_E:
			v := o.E
			value := protoreflect.ValueOfInt32(v)
			if !f(fd_TestVersion3LoneOneOfValue_e, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersion3LoneOneOfValue_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_9_list{list: &x.H})
		if !f(fd_TestVersion3LoneOneOfValue_h, value) {
			return
		}
	}
	if x.K != nil {
		value := protoreflect.ValueOfMessage(x.K.ProtoReflect())
		if !f(fd_TestVersion3LoneOneOfValue_k, value) {
			return
		}
	}
	if x.NonCriticalField != "" {
		value := protoreflect.ValueOfString(x.NonCriticalField)
		if !f(fd_TestVersion3LoneOneOfValue_non_critical_field, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion3LoneOneOfValue) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneOneOfValue.x":
		return x.X != int64(0)
	case "testpb.TestVersion3LoneOneOfValue.a":
		return x.A != nil
	case "testpb.TestVersion3LoneOneOfValue.b":
		return x.B != nil
	case "testpb.TestVersion3LoneOneOfValue.c":
		return len(x.C) != 0
	case "testpb.TestVersion3LoneOneOfValue.d":
		return len(x.D) != 0
	case "testpb.TestVersion3LoneOneOfValue.e":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion3LoneOneOfValue_E); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion3LoneOneOfValue.g":
		return x.G != nil
	case "testpb.TestVersion3LoneOneOfValue.h":
		return len(x.H) != 0
	case "testpb.TestVersion3LoneOneOfValue.k":
		return x.K != nil
	case "testpb.TestVersion3LoneOneOfValue.non_critical_field":
		return x.NonCriticalField != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneOneOfValue) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneOneOfValue.x":
		x.X = int64(0)
	case "testpb.TestVersion3LoneOneOfValue.a":
		x.A = nil
	case "testpb.TestVersion3LoneOneOfValue.b":
		x.B = nil
	case "testpb.TestVersion3LoneOneOfValue.c":
		x.C = nil
	case "testpb.TestVersion3LoneOneOfValue.d":
		x.D = nil
	case "testpb.TestVersion3LoneOneOfValue.e":
		x.Sum = nil
	case "testpb.TestVersion3LoneOneOfValue.g":
		x.G = nil
	case "testpb.TestVersion3LoneOneOfValue.h":
		x.H = nil
	case "testpb.TestVersion3LoneOneOfValue.k":
		x.K = nil
	case "testpb.TestVersion3LoneOneOfValue.non_critical_field":
		x.NonCriticalField = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion3LoneOneOfValue) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion3LoneOneOfValue.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion3LoneOneOfValue.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.b":
		value := x.B
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.c":
		if len(x.C) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_4_list{})
		}
		listValue := &_TestVersion3LoneOneOfValue_4_list{list: &x.C}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3LoneOneOfValue.d":
		if len(x.D) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_5_list{})
		}
		listValue := &_TestVersion3LoneOneOfValue_5_list{list: &x.D}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3LoneOneOfValue.e":
		if x.Sum == nil {
			return protoreflect.ValueOfInt32(int32(0))
		} else if v, ok := x.Sum.(*TestVersion3LoneOneOfValue_E); ok {
			return protoreflect.ValueOfInt32(v.E)
		} else {
			return protoreflect.ValueOfInt32(int32(0))
		}
	case "testpb.TestVersion3LoneOneOfValue.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_9_list{})
		}
		listValue := &_TestVersion3LoneOneOfValue_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3LoneOneOfValue.k":
		value := x.K
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.non_critical_field":
		value := x.NonCriticalField
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneOneOfValue) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneOneOfValue.x":
		x.X = value.Int()
	case "testpb.TestVersion3LoneOneOfValue.a":
		x.A = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion3LoneOneOfValue.b":
		x.B = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion3LoneOneOfValue.c":
		lv := value.List()
		clv := lv.(*_TestVersion3LoneOneOfValue_4_list)
		x.C = *clv.list
	case "testpb.TestVersion3LoneOneOfValue.d":
		lv := value.List()
		clv := lv.(*_TestVersion3LoneOneOfValue_5_list)
		x.D = *clv.list
	case "testpb.TestVersion3LoneOneOfValue.e":
		cv := int32(value.Int())
		x.Sum = &TestVersion3LoneOneOfValue_E{E: cv}
	case "testpb.TestVersion3LoneOneOfValue.g":
		x.G = value.Message().Interface().(*anypb.Any)
	case "testpb.TestVersion3LoneOneOfValue.h":
		lv := value.List()
		clv := lv.(*_TestVersion3LoneOneOfValue_9_list)
		x.H = *clv.list
	case "testpb.TestVersion3LoneOneOfValue.k":
		x.K = value.Message().Interface().(*Customer1)
	case "testpb.TestVersion3LoneOneOfValue.non_critical_field":
		x.NonCriticalField = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneOneOfValue) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneOneOfValue.a":
		if x.A == nil {
			x.A = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.b":
		if x.B == nil {
			x.B = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.B.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.c":
		if x.C == nil {
			x.C = []*TestVersion3{}
		}
		value := &_TestVersion3LoneOneOfValue_4_list{list: &x.C}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3LoneOneOfValue.d":
		if x.D == nil {
			x.D = []*TestVersion3{}
		}
		value := &_TestVersion3LoneOneOfValue_5_list{list: &x.D}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3LoneOneOfValue.g":
		if x.G == nil {
			x.G = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersion3LoneOneOfValue_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3LoneOneOfValue.k":
		if x.K == nil {
			x.K = new(Customer1)
		}
		return protoreflect.ValueOfMessage(x.K.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.x":
		panic(fmt.Errorf("field x of message testpb.TestVersion3LoneOneOfValue is not mutable"))
	case "testpb.TestVersion3LoneOneOfValue.e":
		panic(fmt.Errorf("field e of message testpb.TestVersion3LoneOneOfValue is not mutable"))
	case "testpb.TestVersion3LoneOneOfValue.non_critical_field":
		panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion3LoneOneOfValue is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion3LoneOneOfValue) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneOneOfValue.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion3LoneOneOfValue.a":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.b":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.c":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_4_list{list: &list})
	case "testpb.TestVersion3LoneOneOfValue.d":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_5_list{list: &list})
	case "testpb.TestVersion3LoneOneOfValue.e":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.TestVersion3LoneOneOfValue.g":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion3LoneOneOfValue_9_list{list: &list})
	case "testpb.TestVersion3LoneOneOfValue.k":
		m := new(Customer1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneOneOfValue.non_critical_field":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneOneOfValue"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneOneOfValue does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion3LoneOneOfValue) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersion3LoneOneOfValue.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersion3LoneOneOfValue_E:
			return x.Descriptor().Fields().ByName("e")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneOneOfValue", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion3LoneOneOfValue) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneOneOfValue) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion3LoneOneOfValue) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion3LoneOneOfValue) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion3LoneOneOfValue)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.B != nil {
			l = options.Size(x.B)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.C) > 0 {
			for _, e := range x.C {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.D) > 0 {
			for _, e := range x.D {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		switch x := x.Sum.(type) {
		case *TestVersion3LoneOneOfValue_E:
			if x == nil {
				break
			}
			n += 1 + runtime.Sov(uint64(x.E))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.K != nil {
			l = options.Size(x.K)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.NonCriticalField)
		if l > 0 {
			n += 2 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneOneOfValue)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersion3LoneOneOfValue_E:
			i = runtime.EncodeVarint(dAtA, i, uint64(x.E))
			i--
			dAtA[i] = 0x30
		}
		if len(x.NonCriticalField) > 0 {
			i -= len(x.NonCriticalField)
			copy(dAtA[i:], x.NonCriticalField)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField)))
			i--
			dAtA[i] = 0x40
			i--
			dAtA[i] = 0xba
		}
		if x.K != nil {
			encoded, err := options.Marshal(x.K)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x62
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.D) > 0 {
			for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.D[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x2a
			}
		}
		if len(x.C) > 0 {
			for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.C[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if x.B != nil {
			encoded, err := options.Marshal(x.B)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneOneOfValue)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneOneOfValue: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneOneOfValue: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.B == nil {
					x.B = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.C = append(x.C, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.D = append(x.D, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 6:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType)
				}
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Sum = &TestVersion3LoneOneOfValue_E{v}
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 12:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.K == nil {
					x.K = &Customer1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 1031:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NonCriticalField = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersion3LoneNesting_4_list)(nil)

type _TestVersion3LoneNesting_4_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion3LoneNesting_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3LoneNesting_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3LoneNesting_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3LoneNesting_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3LoneNesting_4_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneNesting_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3LoneNesting_4_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneNesting_4_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion3LoneNesting_5_list)(nil)

type _TestVersion3LoneNesting_5_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion3LoneNesting_5_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3LoneNesting_5_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3LoneNesting_5_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3LoneNesting_5_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3LoneNesting_5_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneNesting_5_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3LoneNesting_5_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneNesting_5_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion3LoneNesting_9_list)(nil)

type _TestVersion3LoneNesting_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion3LoneNesting_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion3LoneNesting_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion3LoneNesting_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion3LoneNesting_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion3LoneNesting_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneNesting_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion3LoneNesting_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion3LoneNesting_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersion3LoneNesting                    protoreflect.MessageDescriptor
	fd_TestVersion3LoneNesting_x                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_a                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_b                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_c                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_d                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_f                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_g                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_h                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_k                  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_non_critical_field protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_inner1             protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_inner2             protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion3LoneNesting = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting")
	fd_TestVersion3LoneNesting_x = md_TestVersion3LoneNesting.Fields().ByName("x")
	fd_TestVersion3LoneNesting_a = md_TestVersion3LoneNesting.Fields().ByName("a")
	fd_TestVersion3LoneNesting_b = md_TestVersion3LoneNesting.Fields().ByName("b")
	fd_TestVersion3LoneNesting_c = md_TestVersion3LoneNesting.Fields().ByName("c")
	fd_TestVersion3LoneNesting_d = md_TestVersion3LoneNesting.Fields().ByName("d")
	fd_TestVersion3LoneNesting_f = md_TestVersion3LoneNesting.Fields().ByName("f")
	fd_TestVersion3LoneNesting_g = md_TestVersion3LoneNesting.Fields().ByName("g")
	fd_TestVersion3LoneNesting_h = md_TestVersion3LoneNesting.Fields().ByName("h")
	fd_TestVersion3LoneNesting_k = md_TestVersion3LoneNesting.Fields().ByName("k")
	fd_TestVersion3LoneNesting_non_critical_field = md_TestVersion3LoneNesting.Fields().ByName("non_critical_field")
	fd_TestVersion3LoneNesting_inner1 = md_TestVersion3LoneNesting.Fields().ByName("inner1")
	fd_TestVersion3LoneNesting_inner2 = md_TestVersion3LoneNesting.Fields().ByName("inner2")
}

var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting)(nil)

type fastReflection_TestVersion3LoneNesting TestVersion3LoneNesting

func (x *TestVersion3LoneNesting) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting)(x)
}

func (x *TestVersion3LoneNesting) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[15]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion3LoneNesting_messageType fastReflection_TestVersion3LoneNesting_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_messageType{}

type fastReflection_TestVersion3LoneNesting_messageType struct{}

func (x fastReflection_TestVersion3LoneNesting_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting)(nil)
}
func (x fastReflection_TestVersion3LoneNesting_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting)
}
func (x fastReflection_TestVersion3LoneNesting_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion3LoneNesting) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion3LoneNesting) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion3LoneNesting_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion3LoneNesting) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion3LoneNesting) Interface() protoreflect.ProtoMessage {
	return (*TestVersion3LoneNesting)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion3LoneNesting) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersion3LoneNesting_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_a, value) {
			return
		}
	}
	if x.B != nil {
		value := protoreflect.ValueOfMessage(x.B.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_b, value) {
			return
		}
	}
	if len(x.C) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3LoneNesting_4_list{list: &x.C})
		if !f(fd_TestVersion3LoneNesting_c, value) {
			return
		}
	}
	if len(x.D) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3LoneNesting_5_list{list: &x.D})
		if !f(fd_TestVersion3LoneNesting_d, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersion3LoneNesting_F:
			v := o.F
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_TestVersion3LoneNesting_f, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion3LoneNesting_9_list{list: &x.H})
		if !f(fd_TestVersion3LoneNesting_h, value) {
			return
		}
	}
	if x.K != nil {
		value := protoreflect.ValueOfMessage(x.K.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_k, value) {
			return
		}
	}
	if x.NonCriticalField != "" {
		value := protoreflect.ValueOfString(x.NonCriticalField)
		if !f(fd_TestVersion3LoneNesting_non_critical_field, value) {
			return
		}
	}
	if x.Inner1 != nil {
		value := protoreflect.ValueOfMessage(x.Inner1.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_inner1, value) {
			return
		}
	}
	if x.Inner2 != nil {
		value := protoreflect.ValueOfMessage(x.Inner2.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_inner2, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion3LoneNesting) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.x":
		return x.X != int64(0)
	case "testpb.TestVersion3LoneNesting.a":
		return x.A != nil
	case "testpb.TestVersion3LoneNesting.b":
		return x.B != nil
	case "testpb.TestVersion3LoneNesting.c":
		return len(x.C) != 0
	case "testpb.TestVersion3LoneNesting.d":
		return len(x.D) != 0
	case "testpb.TestVersion3LoneNesting.f":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion3LoneNesting_F); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion3LoneNesting.g":
		return x.G != nil
	case "testpb.TestVersion3LoneNesting.h":
		return len(x.H) != 0
	case "testpb.TestVersion3LoneNesting.k":
		return x.K != nil
	case "testpb.TestVersion3LoneNesting.non_critical_field":
		return x.NonCriticalField != ""
	case "testpb.TestVersion3LoneNesting.inner1":
		return x.Inner1 != nil
	case "testpb.TestVersion3LoneNesting.inner2":
		return x.Inner2 != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.x":
		x.X = int64(0)
	case "testpb.TestVersion3LoneNesting.a":
		x.A = nil
	case "testpb.TestVersion3LoneNesting.b":
		x.B = nil
	case "testpb.TestVersion3LoneNesting.c":
		x.C = nil
	case "testpb.TestVersion3LoneNesting.d":
		x.D = nil
	case "testpb.TestVersion3LoneNesting.f":
		x.Sum = nil
	case "testpb.TestVersion3LoneNesting.g":
		x.G = nil
	case "testpb.TestVersion3LoneNesting.h":
		x.H = nil
	case "testpb.TestVersion3LoneNesting.k":
		x.K = nil
	case "testpb.TestVersion3LoneNesting.non_critical_field":
		x.NonCriticalField = ""
	case "testpb.TestVersion3LoneNesting.inner1":
		x.Inner1 = nil
	case "testpb.TestVersion3LoneNesting.inner2":
		x.Inner2 = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion3LoneNesting) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion3LoneNesting.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion3LoneNesting.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.b":
		value := x.B
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.c":
		if len(x.C) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3LoneNesting_4_list{})
		}
		listValue := &_TestVersion3LoneNesting_4_list{list: &x.C}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3LoneNesting.d":
		if len(x.D) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3LoneNesting_5_list{})
		}
		listValue := &_TestVersion3LoneNesting_5_list{list: &x.D}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3LoneNesting.f":
		if x.Sum == nil {
			return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect())
		} else if v, ok := x.Sum.(*TestVersion3LoneNesting_F); ok {
			return protoreflect.ValueOfMessage(v.F.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect())
		}
	case "testpb.TestVersion3LoneNesting.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersion3LoneNesting_9_list{})
		}
		listValue := &_TestVersion3LoneNesting_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion3LoneNesting.k":
		value := x.K
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.non_critical_field":
		value := x.NonCriticalField
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion3LoneNesting.inner1":
		value := x.Inner1
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.inner2":
		value := x.Inner2
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.x":
		x.X = value.Int()
	case "testpb.TestVersion3LoneNesting.a":
		x.A = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion3LoneNesting.b":
		x.B = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion3LoneNesting.c":
		lv := value.List()
		clv := lv.(*_TestVersion3LoneNesting_4_list)
		x.C = *clv.list
	case "testpb.TestVersion3LoneNesting.d":
		lv := value.List()
		clv := lv.(*_TestVersion3LoneNesting_5_list)
		x.D = *clv.list
	case "testpb.TestVersion3LoneNesting.f":
		cv := value.Message().Interface().(*TestVersion3LoneNesting)
		x.Sum = &TestVersion3LoneNesting_F{F: cv}
	case "testpb.TestVersion3LoneNesting.g":
		x.G = value.Message().Interface().(*anypb.Any)
	case "testpb.TestVersion3LoneNesting.h":
		lv := value.List()
		clv := lv.(*_TestVersion3LoneNesting_9_list)
		x.H = *clv.list
	case "testpb.TestVersion3LoneNesting.k":
		x.K = value.Message().Interface().(*Customer1)
	case "testpb.TestVersion3LoneNesting.non_critical_field":
		x.NonCriticalField = value.Interface().(string)
	case "testpb.TestVersion3LoneNesting.inner1":
		x.Inner1 = value.Message().Interface().(*TestVersion3LoneNesting_Inner1)
	case "testpb.TestVersion3LoneNesting.inner2":
		x.Inner2 = value.Message().Interface().(*TestVersion3LoneNesting_Inner2)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.a":
		if x.A == nil {
			x.A = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.b":
		if x.B == nil {
			x.B = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.B.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.c":
		if x.C == nil {
			x.C = []*TestVersion3{}
		}
		value := &_TestVersion3LoneNesting_4_list{list: &x.C}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3LoneNesting.d":
		if x.D == nil {
			x.D = []*TestVersion3{}
		}
		value := &_TestVersion3LoneNesting_5_list{list: &x.D}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3LoneNesting.f":
		if x.Sum == nil {
			value := &TestVersion3LoneNesting{}
			oneofValue := &TestVersion3LoneNesting_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Sum.(type) {
		case *TestVersion3LoneNesting_F:
			return protoreflect.ValueOfMessage(m.F.ProtoReflect())
		default:
			value := &TestVersion3LoneNesting{}
			oneofValue := &TestVersion3LoneNesting_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "testpb.TestVersion3LoneNesting.g":
		if x.G == nil {
			x.G = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersion3LoneNesting_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion3LoneNesting.k":
		if x.K == nil {
			x.K = new(Customer1)
		}
		return protoreflect.ValueOfMessage(x.K.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.inner1":
		if x.Inner1 == nil {
			x.Inner1 = new(TestVersion3LoneNesting_Inner1)
		}
		return protoreflect.ValueOfMessage(x.Inner1.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.inner2":
		if x.Inner2 == nil {
			x.Inner2 = new(TestVersion3LoneNesting_Inner2)
		}
		return protoreflect.ValueOfMessage(x.Inner2.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.x":
		panic(fmt.Errorf("field x of message testpb.TestVersion3LoneNesting is not mutable"))
	case "testpb.TestVersion3LoneNesting.non_critical_field":
		panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion3LoneNesting is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion3LoneNesting) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion3LoneNesting.a":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.b":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.c":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion3LoneNesting_4_list{list: &list})
	case "testpb.TestVersion3LoneNesting.d":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion3LoneNesting_5_list{list: &list})
	case "testpb.TestVersion3LoneNesting.f":
		value := &TestVersion3LoneNesting{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.g":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion3LoneNesting_9_list{list: &list})
	case "testpb.TestVersion3LoneNesting.k":
		m := new(Customer1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.non_critical_field":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion3LoneNesting.inner1":
		m := new(TestVersion3LoneNesting_Inner1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.inner2":
		m := new(TestVersion3LoneNesting_Inner2)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion3LoneNesting) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersion3LoneNesting.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersion3LoneNesting_F:
			return x.Descriptor().Fields().ByName("f")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion3LoneNesting) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion3LoneNesting) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion3LoneNesting) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion3LoneNesting)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.B != nil {
			l = options.Size(x.B)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.C) > 0 {
			for _, e := range x.C {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.D) > 0 {
			for _, e := range x.D {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		switch x := x.Sum.(type) {
		case *TestVersion3LoneNesting_F:
			if x == nil {
				break
			}
			l = options.Size(x.F)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.K != nil {
			l = options.Size(x.K)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.NonCriticalField)
		if l > 0 {
			n += 2 + l + runtime.Sov(uint64(l))
		}
		if x.Inner1 != nil {
			l = options.Size(x.Inner1)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Inner2 != nil {
			l = options.Size(x.Inner2)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersion3LoneNesting_F:
			encoded, err := options.Marshal(x.F)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.NonCriticalField) > 0 {
			i -= len(x.NonCriticalField)
			copy(dAtA[i:], x.NonCriticalField)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField)))
			i--
			dAtA[i] = 0x40
			i--
			dAtA[i] = 0xba
		}
		if x.Inner2 != nil {
			encoded, err := options.Marshal(x.Inner2)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x7a
		}
		if x.Inner1 != nil {
			encoded, err := options.Marshal(x.Inner1)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x72
		}
		if x.K != nil {
			encoded, err := options.Marshal(x.K)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x62
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.D) > 0 {
			for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.D[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x2a
			}
		}
		if len(x.C) > 0 {
			for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.C[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if x.B != nil {
			encoded, err := options.Marshal(x.B)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.B == nil {
					x.B = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.C = append(x.C, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.D = append(x.D, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v := &TestVersion3LoneNesting{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Sum = &TestVersion3LoneNesting_F{v}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 12:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.K == nil {
					x.K = &Customer1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 1031:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NonCriticalField = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 14:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner1", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner1 == nil {
					x.Inner1 = &TestVersion3LoneNesting_Inner1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner1); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 15:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner2", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner2 == nil {
					x.Inner2 = &TestVersion3LoneNesting_Inner2{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner2); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion3LoneNesting_Inner1       protoreflect.MessageDescriptor
	fd_TestVersion3LoneNesting_Inner1_id    protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_Inner1_name  protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_Inner1_inner protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion3LoneNesting_Inner1 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner1")
	fd_TestVersion3LoneNesting_Inner1_id = md_TestVersion3LoneNesting_Inner1.Fields().ByName("id")
	fd_TestVersion3LoneNesting_Inner1_name = md_TestVersion3LoneNesting_Inner1.Fields().ByName("name")
	fd_TestVersion3LoneNesting_Inner1_inner = md_TestVersion3LoneNesting_Inner1.Fields().ByName("inner")
}

var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner1)(nil)

type fastReflection_TestVersion3LoneNesting_Inner1 TestVersion3LoneNesting_Inner1

func (x *TestVersion3LoneNesting_Inner1) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner1)(x)
}

func (x *TestVersion3LoneNesting_Inner1) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[25]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion3LoneNesting_Inner1_messageType fastReflection_TestVersion3LoneNesting_Inner1_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner1_messageType{}

type fastReflection_TestVersion3LoneNesting_Inner1_messageType struct{}

func (x fastReflection_TestVersion3LoneNesting_Inner1_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner1)(nil)
}
func (x fastReflection_TestVersion3LoneNesting_Inner1_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner1)
}
func (x fastReflection_TestVersion3LoneNesting_Inner1_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner1
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner1
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion3LoneNesting_Inner1_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner1)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Interface() protoreflect.ProtoMessage {
	return (*TestVersion3LoneNesting_Inner1)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int64(0) {
		value := protoreflect.ValueOfInt64(x.Id)
		if !f(fd_TestVersion3LoneNesting_Inner1_id, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_TestVersion3LoneNesting_Inner1_name, value) {
			return
		}
	}
	if x.Inner != nil {
		value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_Inner1_inner, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.id":
		return x.Id != int64(0)
	case "testpb.TestVersion3LoneNesting.Inner1.name":
		return x.Name != ""
	case "testpb.TestVersion3LoneNesting.Inner1.inner":
		return x.Inner != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.id":
		x.Id = int64(0)
	case "testpb.TestVersion3LoneNesting.Inner1.name":
		x.Name = ""
	case "testpb.TestVersion3LoneNesting.Inner1.inner":
		x.Inner = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.id":
		value := x.Id
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion3LoneNesting.Inner1.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion3LoneNesting.Inner1.inner":
		value := x.Inner
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.id":
		x.Id = value.Int()
	case "testpb.TestVersion3LoneNesting.Inner1.name":
		x.Name = value.Interface().(string)
	case "testpb.TestVersion3LoneNesting.Inner1.inner":
		x.Inner = value.Message().Interface().(*TestVersion3LoneNesting_Inner1_InnerInner)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.inner":
		if x.Inner == nil {
			x.Inner = new(TestVersion3LoneNesting_Inner1_InnerInner)
		}
		return protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.Inner1.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner1 is not mutable"))
	case "testpb.TestVersion3LoneNesting.Inner1.name":
		panic(fmt.Errorf("field name of message testpb.TestVersion3LoneNesting.Inner1 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.id":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion3LoneNesting.Inner1.name":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion3LoneNesting.Inner1.inner":
		m := new(TestVersion3LoneNesting_Inner1_InnerInner)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner1", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion3LoneNesting_Inner1) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Inner != nil {
			l = options.Size(x.Inner)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Inner != nil {
			encoded, err := options.Marshal(x.Inner)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner == nil {
					x.Inner = &TestVersion3LoneNesting_Inner1_InnerInner{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion3LoneNesting_Inner1_InnerInner      protoreflect.MessageDescriptor
	fd_TestVersion3LoneNesting_Inner1_InnerInner_id   protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_Inner1_InnerInner_city protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion3LoneNesting_Inner1_InnerInner = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner1").Messages().ByName("InnerInner")
	fd_TestVersion3LoneNesting_Inner1_InnerInner_id = md_TestVersion3LoneNesting_Inner1_InnerInner.Fields().ByName("id")
	fd_TestVersion3LoneNesting_Inner1_InnerInner_city = md_TestVersion3LoneNesting_Inner1_InnerInner.Fields().ByName("city")
}

var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)(nil)

type fastReflection_TestVersion3LoneNesting_Inner1_InnerInner TestVersion3LoneNesting_Inner1_InnerInner

func (x *TestVersion3LoneNesting_Inner1_InnerInner) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)(x)
}

func (x *TestVersion3LoneNesting_Inner1_InnerInner) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[27]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType{}

type fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType struct{}

func (x fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)(nil)
}
func (x fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)
}
func (x fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner1_InnerInner
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner1_InnerInner
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion3LoneNesting_Inner1_InnerInner_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner1_InnerInner)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Interface() protoreflect.ProtoMessage {
	return (*TestVersion3LoneNesting_Inner1_InnerInner)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != "" {
		value := protoreflect.ValueOfString(x.Id)
		if !f(fd_TestVersion3LoneNesting_Inner1_InnerInner_id, value) {
			return
		}
	}
	if x.City != "" {
		value := protoreflect.ValueOfString(x.City)
		if !f(fd_TestVersion3LoneNesting_Inner1_InnerInner_city, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id":
		return x.Id != ""
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city":
		return x.City != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id":
		x.Id = ""
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city":
		x.City = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id":
		value := x.Id
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city":
		value := x.City
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id":
		x.Id = value.Interface().(string)
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city":
		x.City = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner1.InnerInner is not mutable"))
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city":
		panic(fmt.Errorf("field city of message testpb.TestVersion3LoneNesting.Inner1.InnerInner is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.id":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion3LoneNesting.Inner1.InnerInner.city":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner1.InnerInner", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion3LoneNesting_Inner1_InnerInner) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1_InnerInner)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Id)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.City)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1_InnerInner)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.City) > 0 {
			i -= len(x.City)
			copy(dAtA[i:], x.City)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.City)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Id) > 0 {
			i -= len(x.Id)
			copy(dAtA[i:], x.Id)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner1_InnerInner)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1_InnerInner: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner1_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Id = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.City = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion3LoneNesting_Inner2         protoreflect.MessageDescriptor
	fd_TestVersion3LoneNesting_Inner2_id      protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_Inner2_country protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_Inner2_inner   protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion3LoneNesting_Inner2 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner2")
	fd_TestVersion3LoneNesting_Inner2_id = md_TestVersion3LoneNesting_Inner2.Fields().ByName("id")
	fd_TestVersion3LoneNesting_Inner2_country = md_TestVersion3LoneNesting_Inner2.Fields().ByName("country")
	fd_TestVersion3LoneNesting_Inner2_inner = md_TestVersion3LoneNesting_Inner2.Fields().ByName("inner")
}

var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner2)(nil)

type fastReflection_TestVersion3LoneNesting_Inner2 TestVersion3LoneNesting_Inner2

func (x *TestVersion3LoneNesting_Inner2) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner2)(x)
}

func (x *TestVersion3LoneNesting_Inner2) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[26]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion3LoneNesting_Inner2_messageType fastReflection_TestVersion3LoneNesting_Inner2_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner2_messageType{}

type fastReflection_TestVersion3LoneNesting_Inner2_messageType struct{}

func (x fastReflection_TestVersion3LoneNesting_Inner2_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner2)(nil)
}
func (x fastReflection_TestVersion3LoneNesting_Inner2_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner2)
}
func (x fastReflection_TestVersion3LoneNesting_Inner2_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner2
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner2
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion3LoneNesting_Inner2_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner2)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Interface() protoreflect.ProtoMessage {
	return (*TestVersion3LoneNesting_Inner2)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != "" {
		value := protoreflect.ValueOfString(x.Id)
		if !f(fd_TestVersion3LoneNesting_Inner2_id, value) {
			return
		}
	}
	if x.Country != "" {
		value := protoreflect.ValueOfString(x.Country)
		if !f(fd_TestVersion3LoneNesting_Inner2_country, value) {
			return
		}
	}
	if x.Inner != nil {
		value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
		if !f(fd_TestVersion3LoneNesting_Inner2_inner, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.id":
		return x.Id != ""
	case "testpb.TestVersion3LoneNesting.Inner2.country":
		return x.Country != ""
	case "testpb.TestVersion3LoneNesting.Inner2.inner":
		return x.Inner != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.id":
		x.Id = ""
	case "testpb.TestVersion3LoneNesting.Inner2.country":
		x.Country = ""
	case "testpb.TestVersion3LoneNesting.Inner2.inner":
		x.Inner = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.id":
		value := x.Id
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion3LoneNesting.Inner2.country":
		value := x.Country
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion3LoneNesting.Inner2.inner":
		value := x.Inner
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.id":
		x.Id = value.Interface().(string)
	case "testpb.TestVersion3LoneNesting.Inner2.country":
		x.Country = value.Interface().(string)
	case "testpb.TestVersion3LoneNesting.Inner2.inner":
		x.Inner = value.Message().Interface().(*TestVersion3LoneNesting_Inner2_InnerInner)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.inner":
		if x.Inner == nil {
			x.Inner = new(TestVersion3LoneNesting_Inner2_InnerInner)
		}
		return protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
	case "testpb.TestVersion3LoneNesting.Inner2.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner2 is not mutable"))
	case "testpb.TestVersion3LoneNesting.Inner2.country":
		panic(fmt.Errorf("field country of message testpb.TestVersion3LoneNesting.Inner2 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.id":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion3LoneNesting.Inner2.country":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion3LoneNesting.Inner2.inner":
		m := new(TestVersion3LoneNesting_Inner2_InnerInner)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner2", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion3LoneNesting_Inner2) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Id)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.Country)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Inner != nil {
			l = options.Size(x.Inner)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Inner != nil {
			encoded, err := options.Marshal(x.Inner)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Country) > 0 {
			i -= len(x.Country)
			copy(dAtA[i:], x.Country)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Country)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Id) > 0 {
			i -= len(x.Id)
			copy(dAtA[i:], x.Id)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Id = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Country", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Country = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner == nil {
					x.Inner = &TestVersion3LoneNesting_Inner2_InnerInner{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion3LoneNesting_Inner2_InnerInner      protoreflect.MessageDescriptor
	fd_TestVersion3LoneNesting_Inner2_InnerInner_id   protoreflect.FieldDescriptor
	fd_TestVersion3LoneNesting_Inner2_InnerInner_city protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion3LoneNesting_Inner2_InnerInner = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion3LoneNesting").Messages().ByName("Inner2").Messages().ByName("InnerInner")
	fd_TestVersion3LoneNesting_Inner2_InnerInner_id = md_TestVersion3LoneNesting_Inner2_InnerInner.Fields().ByName("id")
	fd_TestVersion3LoneNesting_Inner2_InnerInner_city = md_TestVersion3LoneNesting_Inner2_InnerInner.Fields().ByName("city")
}

var _ protoreflect.Message = (*fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)(nil)

type fastReflection_TestVersion3LoneNesting_Inner2_InnerInner TestVersion3LoneNesting_Inner2_InnerInner

func (x *TestVersion3LoneNesting_Inner2_InnerInner) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)(x)
}

func (x *TestVersion3LoneNesting_Inner2_InnerInner) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[28]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType{}

type fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType struct{}

func (x fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)(nil)
}
func (x fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)
}
func (x fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner2_InnerInner
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion3LoneNesting_Inner2_InnerInner
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion3LoneNesting_Inner2_InnerInner_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) New() protoreflect.Message {
	return new(fastReflection_TestVersion3LoneNesting_Inner2_InnerInner)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Interface() protoreflect.ProtoMessage {
	return (*TestVersion3LoneNesting_Inner2_InnerInner)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != "" {
		value := protoreflect.ValueOfString(x.Id)
		if !f(fd_TestVersion3LoneNesting_Inner2_InnerInner_id, value) {
			return
		}
	}
	if x.City != "" {
		value := protoreflect.ValueOfString(x.City)
		if !f(fd_TestVersion3LoneNesting_Inner2_InnerInner_city, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id":
		return x.Id != ""
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city":
		return x.City != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id":
		x.Id = ""
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city":
		x.City = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id":
		value := x.Id
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city":
		value := x.City
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id":
		x.Id = value.Interface().(string)
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city":
		x.City = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion3LoneNesting.Inner2.InnerInner is not mutable"))
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city":
		panic(fmt.Errorf("field city of message testpb.TestVersion3LoneNesting.Inner2.InnerInner is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.id":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion3LoneNesting.Inner2.InnerInner.city":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion3LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion3LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion3LoneNesting.Inner2.InnerInner", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion3LoneNesting_Inner2_InnerInner) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2_InnerInner)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Id)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.City)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2_InnerInner)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.City) > 0 {
			i -= len(x.City)
			copy(dAtA[i:], x.City)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.City)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Id) > 0 {
			i -= len(x.Id)
			copy(dAtA[i:], x.Id)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion3LoneNesting_Inner2_InnerInner)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2_InnerInner: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion3LoneNesting_Inner2_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Id = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.City = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersion4LoneNesting_4_list)(nil)

type _TestVersion4LoneNesting_4_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion4LoneNesting_4_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion4LoneNesting_4_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion4LoneNesting_4_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion4LoneNesting_4_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion4LoneNesting_4_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion4LoneNesting_4_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion4LoneNesting_4_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion4LoneNesting_4_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion4LoneNesting_5_list)(nil)

type _TestVersion4LoneNesting_5_list struct {
	list *[]*TestVersion3
}

func (x *_TestVersion4LoneNesting_5_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion4LoneNesting_5_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion4LoneNesting_5_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion4LoneNesting_5_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion3)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion4LoneNesting_5_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion3)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion4LoneNesting_5_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion4LoneNesting_5_list) NewElement() protoreflect.Value {
	v := new(TestVersion3)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion4LoneNesting_5_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestVersion4LoneNesting_9_list)(nil)

type _TestVersion4LoneNesting_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersion4LoneNesting_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersion4LoneNesting_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersion4LoneNesting_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersion4LoneNesting_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersion4LoneNesting_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion4LoneNesting_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersion4LoneNesting_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersion4LoneNesting_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersion4LoneNesting                    protoreflect.MessageDescriptor
	fd_TestVersion4LoneNesting_x                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_a                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_b                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_c                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_d                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_f                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_g                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_h                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_k                  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_non_critical_field protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_inner1             protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_inner2             protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion4LoneNesting = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting")
	fd_TestVersion4LoneNesting_x = md_TestVersion4LoneNesting.Fields().ByName("x")
	fd_TestVersion4LoneNesting_a = md_TestVersion4LoneNesting.Fields().ByName("a")
	fd_TestVersion4LoneNesting_b = md_TestVersion4LoneNesting.Fields().ByName("b")
	fd_TestVersion4LoneNesting_c = md_TestVersion4LoneNesting.Fields().ByName("c")
	fd_TestVersion4LoneNesting_d = md_TestVersion4LoneNesting.Fields().ByName("d")
	fd_TestVersion4LoneNesting_f = md_TestVersion4LoneNesting.Fields().ByName("f")
	fd_TestVersion4LoneNesting_g = md_TestVersion4LoneNesting.Fields().ByName("g")
	fd_TestVersion4LoneNesting_h = md_TestVersion4LoneNesting.Fields().ByName("h")
	fd_TestVersion4LoneNesting_k = md_TestVersion4LoneNesting.Fields().ByName("k")
	fd_TestVersion4LoneNesting_non_critical_field = md_TestVersion4LoneNesting.Fields().ByName("non_critical_field")
	fd_TestVersion4LoneNesting_inner1 = md_TestVersion4LoneNesting.Fields().ByName("inner1")
	fd_TestVersion4LoneNesting_inner2 = md_TestVersion4LoneNesting.Fields().ByName("inner2")
}

var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting)(nil)

type fastReflection_TestVersion4LoneNesting TestVersion4LoneNesting

func (x *TestVersion4LoneNesting) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting)(x)
}

func (x *TestVersion4LoneNesting) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[16]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion4LoneNesting_messageType fastReflection_TestVersion4LoneNesting_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_messageType{}

type fastReflection_TestVersion4LoneNesting_messageType struct{}

func (x fastReflection_TestVersion4LoneNesting_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting)(nil)
}
func (x fastReflection_TestVersion4LoneNesting_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting)
}
func (x fastReflection_TestVersion4LoneNesting_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion4LoneNesting) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion4LoneNesting) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion4LoneNesting_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion4LoneNesting) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion4LoneNesting) Interface() protoreflect.ProtoMessage {
	return (*TestVersion4LoneNesting)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion4LoneNesting) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersion4LoneNesting_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_a, value) {
			return
		}
	}
	if x.B != nil {
		value := protoreflect.ValueOfMessage(x.B.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_b, value) {
			return
		}
	}
	if len(x.C) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion4LoneNesting_4_list{list: &x.C})
		if !f(fd_TestVersion4LoneNesting_c, value) {
			return
		}
	}
	if len(x.D) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion4LoneNesting_5_list{list: &x.D})
		if !f(fd_TestVersion4LoneNesting_d, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersion4LoneNesting_F:
			v := o.F
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_TestVersion4LoneNesting_f, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersion4LoneNesting_9_list{list: &x.H})
		if !f(fd_TestVersion4LoneNesting_h, value) {
			return
		}
	}
	if x.K != nil {
		value := protoreflect.ValueOfMessage(x.K.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_k, value) {
			return
		}
	}
	if x.NonCriticalField != "" {
		value := protoreflect.ValueOfString(x.NonCriticalField)
		if !f(fd_TestVersion4LoneNesting_non_critical_field, value) {
			return
		}
	}
	if x.Inner1 != nil {
		value := protoreflect.ValueOfMessage(x.Inner1.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_inner1, value) {
			return
		}
	}
	if x.Inner2 != nil {
		value := protoreflect.ValueOfMessage(x.Inner2.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_inner2, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion4LoneNesting) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.x":
		return x.X != int64(0)
	case "testpb.TestVersion4LoneNesting.a":
		return x.A != nil
	case "testpb.TestVersion4LoneNesting.b":
		return x.B != nil
	case "testpb.TestVersion4LoneNesting.c":
		return len(x.C) != 0
	case "testpb.TestVersion4LoneNesting.d":
		return len(x.D) != 0
	case "testpb.TestVersion4LoneNesting.f":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersion4LoneNesting_F); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersion4LoneNesting.g":
		return x.G != nil
	case "testpb.TestVersion4LoneNesting.h":
		return len(x.H) != 0
	case "testpb.TestVersion4LoneNesting.k":
		return x.K != nil
	case "testpb.TestVersion4LoneNesting.non_critical_field":
		return x.NonCriticalField != ""
	case "testpb.TestVersion4LoneNesting.inner1":
		return x.Inner1 != nil
	case "testpb.TestVersion4LoneNesting.inner2":
		return x.Inner2 != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.x":
		x.X = int64(0)
	case "testpb.TestVersion4LoneNesting.a":
		x.A = nil
	case "testpb.TestVersion4LoneNesting.b":
		x.B = nil
	case "testpb.TestVersion4LoneNesting.c":
		x.C = nil
	case "testpb.TestVersion4LoneNesting.d":
		x.D = nil
	case "testpb.TestVersion4LoneNesting.f":
		x.Sum = nil
	case "testpb.TestVersion4LoneNesting.g":
		x.G = nil
	case "testpb.TestVersion4LoneNesting.h":
		x.H = nil
	case "testpb.TestVersion4LoneNesting.k":
		x.K = nil
	case "testpb.TestVersion4LoneNesting.non_critical_field":
		x.NonCriticalField = ""
	case "testpb.TestVersion4LoneNesting.inner1":
		x.Inner1 = nil
	case "testpb.TestVersion4LoneNesting.inner2":
		x.Inner2 = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion4LoneNesting) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion4LoneNesting.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion4LoneNesting.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.b":
		value := x.B
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.c":
		if len(x.C) == 0 {
			return protoreflect.ValueOfList(&_TestVersion4LoneNesting_4_list{})
		}
		listValue := &_TestVersion4LoneNesting_4_list{list: &x.C}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion4LoneNesting.d":
		if len(x.D) == 0 {
			return protoreflect.ValueOfList(&_TestVersion4LoneNesting_5_list{})
		}
		listValue := &_TestVersion4LoneNesting_5_list{list: &x.D}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion4LoneNesting.f":
		if x.Sum == nil {
			return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect())
		} else if v, ok := x.Sum.(*TestVersion4LoneNesting_F); ok {
			return protoreflect.ValueOfMessage(v.F.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*TestVersion3LoneNesting)(nil).ProtoReflect())
		}
	case "testpb.TestVersion4LoneNesting.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersion4LoneNesting_9_list{})
		}
		listValue := &_TestVersion4LoneNesting_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestVersion4LoneNesting.k":
		value := x.K
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.non_critical_field":
		value := x.NonCriticalField
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion4LoneNesting.inner1":
		value := x.Inner1
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.inner2":
		value := x.Inner2
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.x":
		x.X = value.Int()
	case "testpb.TestVersion4LoneNesting.a":
		x.A = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion4LoneNesting.b":
		x.B = value.Message().Interface().(*TestVersion3)
	case "testpb.TestVersion4LoneNesting.c":
		lv := value.List()
		clv := lv.(*_TestVersion4LoneNesting_4_list)
		x.C = *clv.list
	case "testpb.TestVersion4LoneNesting.d":
		lv := value.List()
		clv := lv.(*_TestVersion4LoneNesting_5_list)
		x.D = *clv.list
	case "testpb.TestVersion4LoneNesting.f":
		cv := value.Message().Interface().(*TestVersion3LoneNesting)
		x.Sum = &TestVersion4LoneNesting_F{F: cv}
	case "testpb.TestVersion4LoneNesting.g":
		x.G = value.Message().Interface().(*anypb.Any)
	case "testpb.TestVersion4LoneNesting.h":
		lv := value.List()
		clv := lv.(*_TestVersion4LoneNesting_9_list)
		x.H = *clv.list
	case "testpb.TestVersion4LoneNesting.k":
		x.K = value.Message().Interface().(*Customer1)
	case "testpb.TestVersion4LoneNesting.non_critical_field":
		x.NonCriticalField = value.Interface().(string)
	case "testpb.TestVersion4LoneNesting.inner1":
		x.Inner1 = value.Message().Interface().(*TestVersion4LoneNesting_Inner1)
	case "testpb.TestVersion4LoneNesting.inner2":
		x.Inner2 = value.Message().Interface().(*TestVersion4LoneNesting_Inner2)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.a":
		if x.A == nil {
			x.A = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.b":
		if x.B == nil {
			x.B = new(TestVersion3)
		}
		return protoreflect.ValueOfMessage(x.B.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.c":
		if x.C == nil {
			x.C = []*TestVersion3{}
		}
		value := &_TestVersion4LoneNesting_4_list{list: &x.C}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion4LoneNesting.d":
		if x.D == nil {
			x.D = []*TestVersion3{}
		}
		value := &_TestVersion4LoneNesting_5_list{list: &x.D}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion4LoneNesting.f":
		if x.Sum == nil {
			value := &TestVersion3LoneNesting{}
			oneofValue := &TestVersion4LoneNesting_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Sum.(type) {
		case *TestVersion4LoneNesting_F:
			return protoreflect.ValueOfMessage(m.F.ProtoReflect())
		default:
			value := &TestVersion3LoneNesting{}
			oneofValue := &TestVersion4LoneNesting_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "testpb.TestVersion4LoneNesting.g":
		if x.G == nil {
			x.G = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersion4LoneNesting_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersion4LoneNesting.k":
		if x.K == nil {
			x.K = new(Customer1)
		}
		return protoreflect.ValueOfMessage(x.K.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.inner1":
		if x.Inner1 == nil {
			x.Inner1 = new(TestVersion4LoneNesting_Inner1)
		}
		return protoreflect.ValueOfMessage(x.Inner1.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.inner2":
		if x.Inner2 == nil {
			x.Inner2 = new(TestVersion4LoneNesting_Inner2)
		}
		return protoreflect.ValueOfMessage(x.Inner2.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.x":
		panic(fmt.Errorf("field x of message testpb.TestVersion4LoneNesting is not mutable"))
	case "testpb.TestVersion4LoneNesting.non_critical_field":
		panic(fmt.Errorf("field non_critical_field of message testpb.TestVersion4LoneNesting is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion4LoneNesting) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion4LoneNesting.a":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.b":
		m := new(TestVersion3)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.c":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion4LoneNesting_4_list{list: &list})
	case "testpb.TestVersion4LoneNesting.d":
		list := []*TestVersion3{}
		return protoreflect.ValueOfList(&_TestVersion4LoneNesting_5_list{list: &list})
	case "testpb.TestVersion4LoneNesting.f":
		value := &TestVersion3LoneNesting{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.g":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersion4LoneNesting_9_list{list: &list})
	case "testpb.TestVersion4LoneNesting.k":
		m := new(Customer1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.non_critical_field":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion4LoneNesting.inner1":
		m := new(TestVersion4LoneNesting_Inner1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.inner2":
		m := new(TestVersion4LoneNesting_Inner2)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion4LoneNesting) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersion4LoneNesting.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersion4LoneNesting_F:
			return x.Descriptor().Fields().ByName("f")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion4LoneNesting) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion4LoneNesting) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion4LoneNesting) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion4LoneNesting)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.B != nil {
			l = options.Size(x.B)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.C) > 0 {
			for _, e := range x.C {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.D) > 0 {
			for _, e := range x.D {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		switch x := x.Sum.(type) {
		case *TestVersion4LoneNesting_F:
			if x == nil {
				break
			}
			l = options.Size(x.F)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.K != nil {
			l = options.Size(x.K)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.NonCriticalField)
		if l > 0 {
			n += 2 + l + runtime.Sov(uint64(l))
		}
		if x.Inner1 != nil {
			l = options.Size(x.Inner1)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Inner2 != nil {
			l = options.Size(x.Inner2)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersion4LoneNesting_F:
			encoded, err := options.Marshal(x.F)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.NonCriticalField) > 0 {
			i -= len(x.NonCriticalField)
			copy(dAtA[i:], x.NonCriticalField)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NonCriticalField)))
			i--
			dAtA[i] = 0x40
			i--
			dAtA[i] = 0xba
		}
		if x.Inner2 != nil {
			encoded, err := options.Marshal(x.Inner2)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x7a
		}
		if x.Inner1 != nil {
			encoded, err := options.Marshal(x.Inner1)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x72
		}
		if x.K != nil {
			encoded, err := options.Marshal(x.K)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x62
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if len(x.D) > 0 {
			for iNdEx := len(x.D) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.D[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x2a
			}
		}
		if len(x.C) > 0 {
			for iNdEx := len(x.C) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.C[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x22
			}
		}
		if x.B != nil {
			encoded, err := options.Marshal(x.B)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.B == nil {
					x.B = &TestVersion3{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.B); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 4:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.C = append(x.C, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.C[len(x.C)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field D", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.D = append(x.D, &TestVersion3{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.D[len(x.D)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v := &TestVersion3LoneNesting{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Sum = &TestVersion4LoneNesting_F{v}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 12:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field K", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.K == nil {
					x.K = &Customer1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.K); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 1031:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalField", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NonCriticalField = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 14:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner1", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner1 == nil {
					x.Inner1 = &TestVersion4LoneNesting_Inner1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner1); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 15:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner2", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner2 == nil {
					x.Inner2 = &TestVersion4LoneNesting_Inner2{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner2); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion4LoneNesting_Inner1       protoreflect.MessageDescriptor
	fd_TestVersion4LoneNesting_Inner1_id    protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_Inner1_name  protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_Inner1_inner protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion4LoneNesting_Inner1 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner1")
	fd_TestVersion4LoneNesting_Inner1_id = md_TestVersion4LoneNesting_Inner1.Fields().ByName("id")
	fd_TestVersion4LoneNesting_Inner1_name = md_TestVersion4LoneNesting_Inner1.Fields().ByName("name")
	fd_TestVersion4LoneNesting_Inner1_inner = md_TestVersion4LoneNesting_Inner1.Fields().ByName("inner")
}

var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner1)(nil)

type fastReflection_TestVersion4LoneNesting_Inner1 TestVersion4LoneNesting_Inner1

func (x *TestVersion4LoneNesting_Inner1) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner1)(x)
}

func (x *TestVersion4LoneNesting_Inner1) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[29]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion4LoneNesting_Inner1_messageType fastReflection_TestVersion4LoneNesting_Inner1_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner1_messageType{}

type fastReflection_TestVersion4LoneNesting_Inner1_messageType struct{}

func (x fastReflection_TestVersion4LoneNesting_Inner1_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner1)(nil)
}
func (x fastReflection_TestVersion4LoneNesting_Inner1_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner1)
}
func (x fastReflection_TestVersion4LoneNesting_Inner1_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner1
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner1
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion4LoneNesting_Inner1_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner1)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Interface() protoreflect.ProtoMessage {
	return (*TestVersion4LoneNesting_Inner1)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int64(0) {
		value := protoreflect.ValueOfInt64(x.Id)
		if !f(fd_TestVersion4LoneNesting_Inner1_id, value) {
			return
		}
	}
	if x.Name != "" {
		value := protoreflect.ValueOfString(x.Name)
		if !f(fd_TestVersion4LoneNesting_Inner1_name, value) {
			return
		}
	}
	if x.Inner != nil {
		value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_Inner1_inner, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.id":
		return x.Id != int64(0)
	case "testpb.TestVersion4LoneNesting.Inner1.name":
		return x.Name != ""
	case "testpb.TestVersion4LoneNesting.Inner1.inner":
		return x.Inner != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.id":
		x.Id = int64(0)
	case "testpb.TestVersion4LoneNesting.Inner1.name":
		x.Name = ""
	case "testpb.TestVersion4LoneNesting.Inner1.inner":
		x.Inner = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.id":
		value := x.Id
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion4LoneNesting.Inner1.name":
		value := x.Name
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion4LoneNesting.Inner1.inner":
		value := x.Inner
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.id":
		x.Id = value.Int()
	case "testpb.TestVersion4LoneNesting.Inner1.name":
		x.Name = value.Interface().(string)
	case "testpb.TestVersion4LoneNesting.Inner1.inner":
		x.Inner = value.Message().Interface().(*TestVersion4LoneNesting_Inner1_InnerInner)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.inner":
		if x.Inner == nil {
			x.Inner = new(TestVersion4LoneNesting_Inner1_InnerInner)
		}
		return protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.Inner1.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner1 is not mutable"))
	case "testpb.TestVersion4LoneNesting.Inner1.name":
		panic(fmt.Errorf("field name of message testpb.TestVersion4LoneNesting.Inner1 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.id":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion4LoneNesting.Inner1.name":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion4LoneNesting.Inner1.inner":
		m := new(TestVersion4LoneNesting_Inner1_InnerInner)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner1", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion4LoneNesting_Inner1) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.Name)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Inner != nil {
			l = options.Size(x.Inner)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Inner != nil {
			encoded, err := options.Marshal(x.Inner)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Name) > 0 {
			i -= len(x.Name)
			copy(dAtA[i:], x.Name)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Name)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Name = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner == nil {
					x.Inner = &TestVersion4LoneNesting_Inner1_InnerInner{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion4LoneNesting_Inner1_InnerInner      protoreflect.MessageDescriptor
	fd_TestVersion4LoneNesting_Inner1_InnerInner_id   protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_Inner1_InnerInner_city protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion4LoneNesting_Inner1_InnerInner = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner1").Messages().ByName("InnerInner")
	fd_TestVersion4LoneNesting_Inner1_InnerInner_id = md_TestVersion4LoneNesting_Inner1_InnerInner.Fields().ByName("id")
	fd_TestVersion4LoneNesting_Inner1_InnerInner_city = md_TestVersion4LoneNesting_Inner1_InnerInner.Fields().ByName("city")
}

var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)(nil)

type fastReflection_TestVersion4LoneNesting_Inner1_InnerInner TestVersion4LoneNesting_Inner1_InnerInner

func (x *TestVersion4LoneNesting_Inner1_InnerInner) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)(x)
}

func (x *TestVersion4LoneNesting_Inner1_InnerInner) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[31]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType{}

type fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType struct{}

func (x fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)(nil)
}
func (x fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)
}
func (x fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner1_InnerInner
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner1_InnerInner
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion4LoneNesting_Inner1_InnerInner_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner1_InnerInner)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Interface() protoreflect.ProtoMessage {
	return (*TestVersion4LoneNesting_Inner1_InnerInner)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != int64(0) {
		value := protoreflect.ValueOfInt64(x.Id)
		if !f(fd_TestVersion4LoneNesting_Inner1_InnerInner_id, value) {
			return
		}
	}
	if x.City != "" {
		value := protoreflect.ValueOfString(x.City)
		if !f(fd_TestVersion4LoneNesting_Inner1_InnerInner_city, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id":
		return x.Id != int64(0)
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city":
		return x.City != ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id":
		x.Id = int64(0)
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city":
		x.City = ""
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id":
		value := x.Id
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city":
		value := x.City
		return protoreflect.ValueOfString(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id":
		x.Id = value.Int()
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city":
		x.City = value.Interface().(string)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner1.InnerInner is not mutable"))
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city":
		panic(fmt.Errorf("field city of message testpb.TestVersion4LoneNesting.Inner1.InnerInner is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.id":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersion4LoneNesting.Inner1.InnerInner.city":
		return protoreflect.ValueOfString("")
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner1.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner1.InnerInner does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner1.InnerInner", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion4LoneNesting_Inner1_InnerInner) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1_InnerInner)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.Id != 0 {
			n += 1 + runtime.Sov(uint64(x.Id))
		}
		l = len(x.City)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1_InnerInner)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.City) > 0 {
			i -= len(x.City)
			copy(dAtA[i:], x.City)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.City)))
			i--
			dAtA[i] = 0x12
		}
		if x.Id != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Id))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner1_InnerInner)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1_InnerInner: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner1_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				x.Id = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Id |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field City", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.City = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion4LoneNesting_Inner2         protoreflect.MessageDescriptor
	fd_TestVersion4LoneNesting_Inner2_id      protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_Inner2_country protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_Inner2_inner   protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion4LoneNesting_Inner2 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner2")
	fd_TestVersion4LoneNesting_Inner2_id = md_TestVersion4LoneNesting_Inner2.Fields().ByName("id")
	fd_TestVersion4LoneNesting_Inner2_country = md_TestVersion4LoneNesting_Inner2.Fields().ByName("country")
	fd_TestVersion4LoneNesting_Inner2_inner = md_TestVersion4LoneNesting_Inner2.Fields().ByName("inner")
}

var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner2)(nil)

type fastReflection_TestVersion4LoneNesting_Inner2 TestVersion4LoneNesting_Inner2

func (x *TestVersion4LoneNesting_Inner2) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner2)(x)
}

func (x *TestVersion4LoneNesting_Inner2) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[30]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion4LoneNesting_Inner2_messageType fastReflection_TestVersion4LoneNesting_Inner2_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner2_messageType{}

type fastReflection_TestVersion4LoneNesting_Inner2_messageType struct{}

func (x fastReflection_TestVersion4LoneNesting_Inner2_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner2)(nil)
}
func (x fastReflection_TestVersion4LoneNesting_Inner2_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner2)
}
func (x fastReflection_TestVersion4LoneNesting_Inner2_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner2
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner2
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion4LoneNesting_Inner2_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner2)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Interface() protoreflect.ProtoMessage {
	return (*TestVersion4LoneNesting_Inner2)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != "" {
		value := protoreflect.ValueOfString(x.Id)
		if !f(fd_TestVersion4LoneNesting_Inner2_id, value) {
			return
		}
	}
	if x.Country != "" {
		value := protoreflect.ValueOfString(x.Country)
		if !f(fd_TestVersion4LoneNesting_Inner2_country, value) {
			return
		}
	}
	if x.Inner != nil {
		value := protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
		if !f(fd_TestVersion4LoneNesting_Inner2_inner, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.id":
		return x.Id != ""
	case "testpb.TestVersion4LoneNesting.Inner2.country":
		return x.Country != ""
	case "testpb.TestVersion4LoneNesting.Inner2.inner":
		return x.Inner != nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.id":
		x.Id = ""
	case "testpb.TestVersion4LoneNesting.Inner2.country":
		x.Country = ""
	case "testpb.TestVersion4LoneNesting.Inner2.inner":
		x.Inner = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.id":
		value := x.Id
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion4LoneNesting.Inner2.country":
		value := x.Country
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion4LoneNesting.Inner2.inner":
		value := x.Inner
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.id":
		x.Id = value.Interface().(string)
	case "testpb.TestVersion4LoneNesting.Inner2.country":
		x.Country = value.Interface().(string)
	case "testpb.TestVersion4LoneNesting.Inner2.inner":
		x.Inner = value.Message().Interface().(*TestVersion4LoneNesting_Inner2_InnerInner)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.inner":
		if x.Inner == nil {
			x.Inner = new(TestVersion4LoneNesting_Inner2_InnerInner)
		}
		return protoreflect.ValueOfMessage(x.Inner.ProtoReflect())
	case "testpb.TestVersion4LoneNesting.Inner2.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner2 is not mutable"))
	case "testpb.TestVersion4LoneNesting.Inner2.country":
		panic(fmt.Errorf("field country of message testpb.TestVersion4LoneNesting.Inner2 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.id":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion4LoneNesting.Inner2.country":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion4LoneNesting.Inner2.inner":
		m := new(TestVersion4LoneNesting_Inner2_InnerInner)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner2", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion4LoneNesting_Inner2) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Id)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.Country)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Inner != nil {
			l = options.Size(x.Inner)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Inner != nil {
			encoded, err := options.Marshal(x.Inner)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x1a
		}
		if len(x.Country) > 0 {
			i -= len(x.Country)
			copy(dAtA[i:], x.Country)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Country)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Id) > 0 {
			i -= len(x.Id)
			copy(dAtA[i:], x.Id)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Id = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Country", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Country = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Inner == nil {
					x.Inner = &TestVersion4LoneNesting_Inner2_InnerInner{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Inner); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_TestVersion4LoneNesting_Inner2_InnerInner       protoreflect.MessageDescriptor
	fd_TestVersion4LoneNesting_Inner2_InnerInner_id    protoreflect.FieldDescriptor
	fd_TestVersion4LoneNesting_Inner2_InnerInner_value protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersion4LoneNesting_Inner2_InnerInner = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersion4LoneNesting").Messages().ByName("Inner2").Messages().ByName("InnerInner")
	fd_TestVersion4LoneNesting_Inner2_InnerInner_id = md_TestVersion4LoneNesting_Inner2_InnerInner.Fields().ByName("id")
	fd_TestVersion4LoneNesting_Inner2_InnerInner_value = md_TestVersion4LoneNesting_Inner2_InnerInner.Fields().ByName("value")
}

var _ protoreflect.Message = (*fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)(nil)

type fastReflection_TestVersion4LoneNesting_Inner2_InnerInner TestVersion4LoneNesting_Inner2_InnerInner

func (x *TestVersion4LoneNesting_Inner2_InnerInner) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)(x)
}

func (x *TestVersion4LoneNesting_Inner2_InnerInner) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[32]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType
var _ protoreflect.MessageType = fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType{}

type fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType struct{}

func (x fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)(nil)
}
func (x fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)
}
func (x fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner2_InnerInner
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersion4LoneNesting_Inner2_InnerInner
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Type() protoreflect.MessageType {
	return _fastReflection_TestVersion4LoneNesting_Inner2_InnerInner_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) New() protoreflect.Message {
	return new(fastReflection_TestVersion4LoneNesting_Inner2_InnerInner)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Interface() protoreflect.ProtoMessage {
	return (*TestVersion4LoneNesting_Inner2_InnerInner)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.Id != "" {
		value := protoreflect.ValueOfString(x.Id)
		if !f(fd_TestVersion4LoneNesting_Inner2_InnerInner_id, value) {
			return
		}
	}
	if x.Value != int64(0) {
		value := protoreflect.ValueOfInt64(x.Value)
		if !f(fd_TestVersion4LoneNesting_Inner2_InnerInner_value, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id":
		return x.Id != ""
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value":
		return x.Value != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id":
		x.Id = ""
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value":
		x.Value = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id":
		value := x.Id
		return protoreflect.ValueOfString(value)
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value":
		value := x.Value
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id":
		x.Id = value.Interface().(string)
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value":
		x.Value = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id":
		panic(fmt.Errorf("field id of message testpb.TestVersion4LoneNesting.Inner2.InnerInner is not mutable"))
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value":
		panic(fmt.Errorf("field value of message testpb.TestVersion4LoneNesting.Inner2.InnerInner is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.id":
		return protoreflect.ValueOfString("")
	case "testpb.TestVersion4LoneNesting.Inner2.InnerInner.value":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersion4LoneNesting.Inner2.InnerInner"))
		}
		panic(fmt.Errorf("message testpb.TestVersion4LoneNesting.Inner2.InnerInner does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersion4LoneNesting.Inner2.InnerInner", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersion4LoneNesting_Inner2_InnerInner) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2_InnerInner)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.Id)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.Value != 0 {
			n += 1 + runtime.Sov(uint64(x.Value))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2_InnerInner)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.Value != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.Value))
			i--
			dAtA[i] = 0x10
		}
		if len(x.Id) > 0 {
			i -= len(x.Id)
			copy(dAtA[i:], x.Id)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersion4LoneNesting_Inner2_InnerInner)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2_InnerInner: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersion4LoneNesting_Inner2_InnerInner: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Id = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 2:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
				}
				x.Value = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.Value |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersionFD1_9_list)(nil)

type _TestVersionFD1_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersionFD1_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersionFD1_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersionFD1_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersionFD1_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersionFD1_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersionFD1_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersionFD1_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersionFD1_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersionFD1   protoreflect.MessageDescriptor
	fd_TestVersionFD1_x protoreflect.FieldDescriptor
	fd_TestVersionFD1_a protoreflect.FieldDescriptor
	fd_TestVersionFD1_e protoreflect.FieldDescriptor
	fd_TestVersionFD1_f protoreflect.FieldDescriptor
	fd_TestVersionFD1_g protoreflect.FieldDescriptor
	fd_TestVersionFD1_h protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersionFD1 = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersionFD1")
	fd_TestVersionFD1_x = md_TestVersionFD1.Fields().ByName("x")
	fd_TestVersionFD1_a = md_TestVersionFD1.Fields().ByName("a")
	fd_TestVersionFD1_e = md_TestVersionFD1.Fields().ByName("e")
	fd_TestVersionFD1_f = md_TestVersionFD1.Fields().ByName("f")
	fd_TestVersionFD1_g = md_TestVersionFD1.Fields().ByName("g")
	fd_TestVersionFD1_h = md_TestVersionFD1.Fields().ByName("h")
}

var _ protoreflect.Message = (*fastReflection_TestVersionFD1)(nil)

type fastReflection_TestVersionFD1 TestVersionFD1

func (x *TestVersionFD1) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersionFD1)(x)
}

func (x *TestVersionFD1) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[17]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersionFD1_messageType fastReflection_TestVersionFD1_messageType
var _ protoreflect.MessageType = fastReflection_TestVersionFD1_messageType{}

type fastReflection_TestVersionFD1_messageType struct{}

func (x fastReflection_TestVersionFD1_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersionFD1)(nil)
}
func (x fastReflection_TestVersionFD1_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersionFD1)
}
func (x fastReflection_TestVersionFD1_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersionFD1
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersionFD1) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersionFD1
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersionFD1) Type() protoreflect.MessageType {
	return _fastReflection_TestVersionFD1_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersionFD1) New() protoreflect.Message {
	return new(fastReflection_TestVersionFD1)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersionFD1) Interface() protoreflect.ProtoMessage {
	return (*TestVersionFD1)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersionFD1) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersionFD1_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersionFD1_a, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersionFD1_E:
			v := o.E
			value := protoreflect.ValueOfInt32(v)
			if !f(fd_TestVersionFD1_e, value) {
				return
			}
		case *TestVersionFD1_F:
			v := o.F
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_TestVersionFD1_f, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersionFD1_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersionFD1_9_list{list: &x.H})
		if !f(fd_TestVersionFD1_h, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersionFD1) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersionFD1.x":
		return x.X != int64(0)
	case "testpb.TestVersionFD1.a":
		return x.A != nil
	case "testpb.TestVersionFD1.e":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersionFD1_E); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersionFD1.f":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersionFD1_F); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersionFD1.g":
		return x.G != nil
	case "testpb.TestVersionFD1.h":
		return len(x.H) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersionFD1.x":
		x.X = int64(0)
	case "testpb.TestVersionFD1.a":
		x.A = nil
	case "testpb.TestVersionFD1.e":
		x.Sum = nil
	case "testpb.TestVersionFD1.f":
		x.Sum = nil
	case "testpb.TestVersionFD1.g":
		x.G = nil
	case "testpb.TestVersionFD1.h":
		x.H = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersionFD1) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersionFD1.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersionFD1.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersionFD1.e":
		if x.Sum == nil {
			return protoreflect.ValueOfInt32(int32(0))
		} else if v, ok := x.Sum.(*TestVersionFD1_E); ok {
			return protoreflect.ValueOfInt32(v.E)
		} else {
			return protoreflect.ValueOfInt32(int32(0))
		}
	case "testpb.TestVersionFD1.f":
		if x.Sum == nil {
			return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect())
		} else if v, ok := x.Sum.(*TestVersionFD1_F); ok {
			return protoreflect.ValueOfMessage(v.F.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect())
		}
	case "testpb.TestVersionFD1.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersionFD1.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersionFD1_9_list{})
		}
		listValue := &_TestVersionFD1_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersionFD1.x":
		x.X = value.Int()
	case "testpb.TestVersionFD1.a":
		x.A = value.Message().Interface().(*TestVersion1)
	case "testpb.TestVersionFD1.e":
		cv := int32(value.Int())
		x.Sum = &TestVersionFD1_E{E: cv}
	case "testpb.TestVersionFD1.f":
		cv := value.Message().Interface().(*TestVersion1)
		x.Sum = &TestVersionFD1_F{F: cv}
	case "testpb.TestVersionFD1.g":
		x.G = value.Message().Interface().(*anypb.Any)
	case "testpb.TestVersionFD1.h":
		lv := value.List()
		clv := lv.(*_TestVersionFD1_9_list)
		x.H = *clv.list
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersionFD1.a":
		if x.A == nil {
			x.A = new(TestVersion1)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersionFD1.f":
		if x.Sum == nil {
			value := &TestVersion1{}
			oneofValue := &TestVersionFD1_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Sum.(type) {
		case *TestVersionFD1_F:
			return protoreflect.ValueOfMessage(m.F.ProtoReflect())
		default:
			value := &TestVersion1{}
			oneofValue := &TestVersionFD1_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "testpb.TestVersionFD1.g":
		if x.G == nil {
			x.G = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersionFD1.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersionFD1_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersionFD1.x":
		panic(fmt.Errorf("field x of message testpb.TestVersionFD1 is not mutable"))
	case "testpb.TestVersionFD1.e":
		panic(fmt.Errorf("field e of message testpb.TestVersionFD1 is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersionFD1) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersionFD1.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersionFD1.a":
		m := new(TestVersion1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersionFD1.e":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.TestVersionFD1.f":
		value := &TestVersion1{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersionFD1.g":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersionFD1.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersionFD1_9_list{list: &list})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1 does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersionFD1) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersionFD1.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersionFD1_E:
			return x.Descriptor().Fields().ByName("e")
		case *TestVersionFD1_F:
			return x.Descriptor().Fields().ByName("f")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersionFD1", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersionFD1) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersionFD1) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersionFD1) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersionFD1)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		switch x := x.Sum.(type) {
		case *TestVersionFD1_E:
			if x == nil {
				break
			}
			n += 1 + runtime.Sov(uint64(x.E))
		case *TestVersionFD1_F:
			if x == nil {
				break
			}
			l = options.Size(x.F)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersionFD1)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersionFD1_E:
			i = runtime.EncodeVarint(dAtA, i, uint64(x.E))
			i--
			dAtA[i] = 0x30
		case *TestVersionFD1_F:
			encoded, err := options.Marshal(x.F)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersionFD1)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 6:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType)
				}
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Sum = &TestVersionFD1_E{v}
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v := &TestVersion1{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Sum = &TestVersionFD1_F{v}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestVersionFD1WithExtraAny_9_list)(nil)

type _TestVersionFD1WithExtraAny_9_list struct {
	list *[]*TestVersion1
}

func (x *_TestVersionFD1WithExtraAny_9_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestVersionFD1WithExtraAny_9_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestVersionFD1WithExtraAny_9_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	(*x.list)[i] = concreteValue
}

func (x *_TestVersionFD1WithExtraAny_9_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*TestVersion1)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestVersionFD1WithExtraAny_9_list) AppendMutable() protoreflect.Value {
	v := new(TestVersion1)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersionFD1WithExtraAny_9_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestVersionFD1WithExtraAny_9_list) NewElement() protoreflect.Value {
	v := new(TestVersion1)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestVersionFD1WithExtraAny_9_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestVersionFD1WithExtraAny   protoreflect.MessageDescriptor
	fd_TestVersionFD1WithExtraAny_x protoreflect.FieldDescriptor
	fd_TestVersionFD1WithExtraAny_a protoreflect.FieldDescriptor
	fd_TestVersionFD1WithExtraAny_e protoreflect.FieldDescriptor
	fd_TestVersionFD1WithExtraAny_f protoreflect.FieldDescriptor
	fd_TestVersionFD1WithExtraAny_g protoreflect.FieldDescriptor
	fd_TestVersionFD1WithExtraAny_h protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestVersionFD1WithExtraAny = File_testpb_unknonwnproto_proto.Messages().ByName("TestVersionFD1WithExtraAny")
	fd_TestVersionFD1WithExtraAny_x = md_TestVersionFD1WithExtraAny.Fields().ByName("x")
	fd_TestVersionFD1WithExtraAny_a = md_TestVersionFD1WithExtraAny.Fields().ByName("a")
	fd_TestVersionFD1WithExtraAny_e = md_TestVersionFD1WithExtraAny.Fields().ByName("e")
	fd_TestVersionFD1WithExtraAny_f = md_TestVersionFD1WithExtraAny.Fields().ByName("f")
	fd_TestVersionFD1WithExtraAny_g = md_TestVersionFD1WithExtraAny.Fields().ByName("g")
	fd_TestVersionFD1WithExtraAny_h = md_TestVersionFD1WithExtraAny.Fields().ByName("h")
}

var _ protoreflect.Message = (*fastReflection_TestVersionFD1WithExtraAny)(nil)

type fastReflection_TestVersionFD1WithExtraAny TestVersionFD1WithExtraAny

func (x *TestVersionFD1WithExtraAny) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestVersionFD1WithExtraAny)(x)
}

func (x *TestVersionFD1WithExtraAny) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[18]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestVersionFD1WithExtraAny_messageType fastReflection_TestVersionFD1WithExtraAny_messageType
var _ protoreflect.MessageType = fastReflection_TestVersionFD1WithExtraAny_messageType{}

type fastReflection_TestVersionFD1WithExtraAny_messageType struct{}

func (x fastReflection_TestVersionFD1WithExtraAny_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestVersionFD1WithExtraAny)(nil)
}
func (x fastReflection_TestVersionFD1WithExtraAny_messageType) New() protoreflect.Message {
	return new(fastReflection_TestVersionFD1WithExtraAny)
}
func (x fastReflection_TestVersionFD1WithExtraAny_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersionFD1WithExtraAny
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestVersionFD1WithExtraAny) Descriptor() protoreflect.MessageDescriptor {
	return md_TestVersionFD1WithExtraAny
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestVersionFD1WithExtraAny) Type() protoreflect.MessageType {
	return _fastReflection_TestVersionFD1WithExtraAny_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestVersionFD1WithExtraAny) New() protoreflect.Message {
	return new(fastReflection_TestVersionFD1WithExtraAny)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestVersionFD1WithExtraAny) Interface() protoreflect.ProtoMessage {
	return (*TestVersionFD1WithExtraAny)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestVersionFD1WithExtraAny) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.X != int64(0) {
		value := protoreflect.ValueOfInt64(x.X)
		if !f(fd_TestVersionFD1WithExtraAny_x, value) {
			return
		}
	}
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_TestVersionFD1WithExtraAny_a, value) {
			return
		}
	}
	if x.Sum != nil {
		switch o := x.Sum.(type) {
		case *TestVersionFD1WithExtraAny_E:
			v := o.E
			value := protoreflect.ValueOfInt32(v)
			if !f(fd_TestVersionFD1WithExtraAny_e, value) {
				return
			}
		case *TestVersionFD1WithExtraAny_F:
			v := o.F
			value := protoreflect.ValueOfMessage(v.ProtoReflect())
			if !f(fd_TestVersionFD1WithExtraAny_f, value) {
				return
			}
		}
	}
	if x.G != nil {
		value := protoreflect.ValueOfMessage(x.G.ProtoReflect())
		if !f(fd_TestVersionFD1WithExtraAny_g, value) {
			return
		}
	}
	if len(x.H) != 0 {
		value := protoreflect.ValueOfList(&_TestVersionFD1WithExtraAny_9_list{list: &x.H})
		if !f(fd_TestVersionFD1WithExtraAny_h, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestVersionFD1WithExtraAny) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestVersionFD1WithExtraAny.x":
		return x.X != int64(0)
	case "testpb.TestVersionFD1WithExtraAny.a":
		return x.A != nil
	case "testpb.TestVersionFD1WithExtraAny.e":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersionFD1WithExtraAny_E); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersionFD1WithExtraAny.f":
		if x.Sum == nil {
			return false
		} else if _, ok := x.Sum.(*TestVersionFD1WithExtraAny_F); ok {
			return true
		} else {
			return false
		}
	case "testpb.TestVersionFD1WithExtraAny.g":
		return x.G != nil
	case "testpb.TestVersionFD1WithExtraAny.h":
		return len(x.H) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1WithExtraAny) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestVersionFD1WithExtraAny.x":
		x.X = int64(0)
	case "testpb.TestVersionFD1WithExtraAny.a":
		x.A = nil
	case "testpb.TestVersionFD1WithExtraAny.e":
		x.Sum = nil
	case "testpb.TestVersionFD1WithExtraAny.f":
		x.Sum = nil
	case "testpb.TestVersionFD1WithExtraAny.g":
		x.G = nil
	case "testpb.TestVersionFD1WithExtraAny.h":
		x.H = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestVersionFD1WithExtraAny) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestVersionFD1WithExtraAny.x":
		value := x.X
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestVersionFD1WithExtraAny.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersionFD1WithExtraAny.e":
		if x.Sum == nil {
			return protoreflect.ValueOfInt32(int32(0))
		} else if v, ok := x.Sum.(*TestVersionFD1WithExtraAny_E); ok {
			return protoreflect.ValueOfInt32(v.E)
		} else {
			return protoreflect.ValueOfInt32(int32(0))
		}
	case "testpb.TestVersionFD1WithExtraAny.f":
		if x.Sum == nil {
			return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect())
		} else if v, ok := x.Sum.(*TestVersionFD1WithExtraAny_F); ok {
			return protoreflect.ValueOfMessage(v.F.ProtoReflect())
		} else {
			return protoreflect.ValueOfMessage((*TestVersion1)(nil).ProtoReflect())
		}
	case "testpb.TestVersionFD1WithExtraAny.g":
		value := x.G
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersionFD1WithExtraAny.h":
		if len(x.H) == 0 {
			return protoreflect.ValueOfList(&_TestVersionFD1WithExtraAny_9_list{})
		}
		listValue := &_TestVersionFD1WithExtraAny_9_list{list: &x.H}
		return protoreflect.ValueOfList(listValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1WithExtraAny) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestVersionFD1WithExtraAny.x":
		x.X = value.Int()
	case "testpb.TestVersionFD1WithExtraAny.a":
		x.A = value.Message().Interface().(*TestVersion1)
	case "testpb.TestVersionFD1WithExtraAny.e":
		cv := int32(value.Int())
		x.Sum = &TestVersionFD1WithExtraAny_E{E: cv}
	case "testpb.TestVersionFD1WithExtraAny.f":
		cv := value.Message().Interface().(*TestVersion1)
		x.Sum = &TestVersionFD1WithExtraAny_F{F: cv}
	case "testpb.TestVersionFD1WithExtraAny.g":
		x.G = value.Message().Interface().(*AnyWithExtra)
	case "testpb.TestVersionFD1WithExtraAny.h":
		lv := value.List()
		clv := lv.(*_TestVersionFD1WithExtraAny_9_list)
		x.H = *clv.list
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1WithExtraAny) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersionFD1WithExtraAny.a":
		if x.A == nil {
			x.A = new(TestVersion1)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.TestVersionFD1WithExtraAny.f":
		if x.Sum == nil {
			value := &TestVersion1{}
			oneofValue := &TestVersionFD1WithExtraAny_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
		switch m := x.Sum.(type) {
		case *TestVersionFD1WithExtraAny_F:
			return protoreflect.ValueOfMessage(m.F.ProtoReflect())
		default:
			value := &TestVersion1{}
			oneofValue := &TestVersionFD1WithExtraAny_F{F: value}
			x.Sum = oneofValue
			return protoreflect.ValueOfMessage(value.ProtoReflect())
		}
	case "testpb.TestVersionFD1WithExtraAny.g":
		if x.G == nil {
			x.G = new(AnyWithExtra)
		}
		return protoreflect.ValueOfMessage(x.G.ProtoReflect())
	case "testpb.TestVersionFD1WithExtraAny.h":
		if x.H == nil {
			x.H = []*TestVersion1{}
		}
		value := &_TestVersionFD1WithExtraAny_9_list{list: &x.H}
		return protoreflect.ValueOfList(value)
	case "testpb.TestVersionFD1WithExtraAny.x":
		panic(fmt.Errorf("field x of message testpb.TestVersionFD1WithExtraAny is not mutable"))
	case "testpb.TestVersionFD1WithExtraAny.e":
		panic(fmt.Errorf("field e of message testpb.TestVersionFD1WithExtraAny is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestVersionFD1WithExtraAny) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestVersionFD1WithExtraAny.x":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestVersionFD1WithExtraAny.a":
		m := new(TestVersion1)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersionFD1WithExtraAny.e":
		return protoreflect.ValueOfInt32(int32(0))
	case "testpb.TestVersionFD1WithExtraAny.f":
		value := &TestVersion1{}
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestVersionFD1WithExtraAny.g":
		m := new(AnyWithExtra)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestVersionFD1WithExtraAny.h":
		list := []*TestVersion1{}
		return protoreflect.ValueOfList(&_TestVersionFD1WithExtraAny_9_list{list: &list})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestVersionFD1WithExtraAny"))
		}
		panic(fmt.Errorf("message testpb.TestVersionFD1WithExtraAny does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestVersionFD1WithExtraAny) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	case "testpb.TestVersionFD1WithExtraAny.sum":
		if x.Sum == nil {
			return nil
		}
		switch x.Sum.(type) {
		case *TestVersionFD1WithExtraAny_E:
			return x.Descriptor().Fields().ByName("e")
		case *TestVersionFD1WithExtraAny_F:
			return x.Descriptor().Fields().ByName("f")
		}
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestVersionFD1WithExtraAny", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestVersionFD1WithExtraAny) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestVersionFD1WithExtraAny) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestVersionFD1WithExtraAny) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestVersionFD1WithExtraAny) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestVersionFD1WithExtraAny)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.X != 0 {
			n += 1 + runtime.Sov(uint64(x.X))
		}
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		switch x := x.Sum.(type) {
		case *TestVersionFD1WithExtraAny_E:
			if x == nil {
				break
			}
			n += 1 + runtime.Sov(uint64(x.E))
		case *TestVersionFD1WithExtraAny_F:
			if x == nil {
				break
			}
			l = options.Size(x.F)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.G != nil {
			l = options.Size(x.G)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.H) > 0 {
			for _, e := range x.H {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestVersionFD1WithExtraAny)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		switch x := x.Sum.(type) {
		case *TestVersionFD1WithExtraAny_E:
			i = runtime.EncodeVarint(dAtA, i, uint64(x.E))
			i--
			dAtA[i] = 0x30
		case *TestVersionFD1WithExtraAny_F:
			encoded, err := options.Marshal(x.F)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x3a
		}
		if len(x.H) > 0 {
			for iNdEx := len(x.H) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.H[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x4a
			}
		}
		if x.G != nil {
			encoded, err := options.Marshal(x.G)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x42
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if x.X != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.X))
			i--
			dAtA[i] = 0x8
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestVersionFD1WithExtraAny)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1WithExtraAny: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestVersionFD1WithExtraAny: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field X", wireType)
				}
				x.X = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.X |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &TestVersion1{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 6:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field E", wireType)
				}
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				x.Sum = &TestVersionFD1WithExtraAny_E{v}
			case 7:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				v := &TestVersion1{}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], v); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				x.Sum = &TestVersionFD1WithExtraAny_F{v}
				iNdEx = postIndex
			case 8:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field G", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.G == nil {
					x.G = &AnyWithExtra{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.G); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 9:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field H", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.H = append(x.H, &TestVersion1{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.H[len(x.H)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var (
	md_AnyWithExtra   protoreflect.MessageDescriptor
	fd_AnyWithExtra_a protoreflect.FieldDescriptor
	fd_AnyWithExtra_b protoreflect.FieldDescriptor
	fd_AnyWithExtra_c protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_AnyWithExtra = File_testpb_unknonwnproto_proto.Messages().ByName("AnyWithExtra")
	fd_AnyWithExtra_a = md_AnyWithExtra.Fields().ByName("a")
	fd_AnyWithExtra_b = md_AnyWithExtra.Fields().ByName("b")
	fd_AnyWithExtra_c = md_AnyWithExtra.Fields().ByName("c")
}

var _ protoreflect.Message = (*fastReflection_AnyWithExtra)(nil)

type fastReflection_AnyWithExtra AnyWithExtra

func (x *AnyWithExtra) ProtoReflect() protoreflect.Message {
	return (*fastReflection_AnyWithExtra)(x)
}

func (x *AnyWithExtra) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[19]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_AnyWithExtra_messageType fastReflection_AnyWithExtra_messageType
var _ protoreflect.MessageType = fastReflection_AnyWithExtra_messageType{}

type fastReflection_AnyWithExtra_messageType struct{}

func (x fastReflection_AnyWithExtra_messageType) Zero() protoreflect.Message {
	return (*fastReflection_AnyWithExtra)(nil)
}
func (x fastReflection_AnyWithExtra_messageType) New() protoreflect.Message {
	return new(fastReflection_AnyWithExtra)
}
func (x fastReflection_AnyWithExtra_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_AnyWithExtra
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_AnyWithExtra) Descriptor() protoreflect.MessageDescriptor {
	return md_AnyWithExtra
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_AnyWithExtra) Type() protoreflect.MessageType {
	return _fastReflection_AnyWithExtra_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_AnyWithExtra) New() protoreflect.Message {
	return new(fastReflection_AnyWithExtra)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_AnyWithExtra) Interface() protoreflect.ProtoMessage {
	return (*AnyWithExtra)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_AnyWithExtra) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if x.A != nil {
		value := protoreflect.ValueOfMessage(x.A.ProtoReflect())
		if !f(fd_AnyWithExtra_a, value) {
			return
		}
	}
	if x.B != int64(0) {
		value := protoreflect.ValueOfInt64(x.B)
		if !f(fd_AnyWithExtra_b, value) {
			return
		}
	}
	if x.C != int64(0) {
		value := protoreflect.ValueOfInt64(x.C)
		if !f(fd_AnyWithExtra_c, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_AnyWithExtra) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.AnyWithExtra.a":
		return x.A != nil
	case "testpb.AnyWithExtra.b":
		return x.B != int64(0)
	case "testpb.AnyWithExtra.c":
		return x.C != int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra"))
		}
		panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_AnyWithExtra) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.AnyWithExtra.a":
		x.A = nil
	case "testpb.AnyWithExtra.b":
		x.B = int64(0)
	case "testpb.AnyWithExtra.c":
		x.C = int64(0)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra"))
		}
		panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_AnyWithExtra) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.AnyWithExtra.a":
		value := x.A
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.AnyWithExtra.b":
		value := x.B
		return protoreflect.ValueOfInt64(value)
	case "testpb.AnyWithExtra.c":
		value := x.C
		return protoreflect.ValueOfInt64(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra"))
		}
		panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_AnyWithExtra) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.AnyWithExtra.a":
		x.A = value.Message().Interface().(*anypb.Any)
	case "testpb.AnyWithExtra.b":
		x.B = value.Int()
	case "testpb.AnyWithExtra.c":
		x.C = value.Int()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra"))
		}
		panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_AnyWithExtra) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.AnyWithExtra.a":
		if x.A == nil {
			x.A = new(anypb.Any)
		}
		return protoreflect.ValueOfMessage(x.A.ProtoReflect())
	case "testpb.AnyWithExtra.b":
		panic(fmt.Errorf("field b of message testpb.AnyWithExtra is not mutable"))
	case "testpb.AnyWithExtra.c":
		panic(fmt.Errorf("field c of message testpb.AnyWithExtra is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra"))
		}
		panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_AnyWithExtra) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.AnyWithExtra.a":
		m := new(anypb.Any)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.AnyWithExtra.b":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.AnyWithExtra.c":
		return protoreflect.ValueOfInt64(int64(0))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.AnyWithExtra"))
		}
		panic(fmt.Errorf("message testpb.AnyWithExtra does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_AnyWithExtra) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.AnyWithExtra", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_AnyWithExtra) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_AnyWithExtra) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_AnyWithExtra) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_AnyWithExtra) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*AnyWithExtra)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if x.A != nil {
			l = options.Size(x.A)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.B != 0 {
			n += 1 + runtime.Sov(uint64(x.B))
		}
		if x.C != 0 {
			n += 1 + runtime.Sov(uint64(x.C))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*AnyWithExtra)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if x.C != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.C))
			i--
			dAtA[i] = 0x20
		}
		if x.B != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.B))
			i--
			dAtA[i] = 0x18
		}
		if x.A != nil {
			encoded, err := options.Marshal(x.A)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*AnyWithExtra)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: AnyWithExtra: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: AnyWithExtra: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field A", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.A == nil {
					x.A = &anypb.Any{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.A); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field B", wireType)
				}
				x.B = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.B |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 4:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field C", wireType)
				}
				x.C = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.C |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestUpdatedTxRaw_3_list)(nil)

type _TestUpdatedTxRaw_3_list struct {
	list *[][]byte
}

func (x *_TestUpdatedTxRaw_3_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestUpdatedTxRaw_3_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfBytes((*x.list)[i])
}

func (x *_TestUpdatedTxRaw_3_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Bytes()
	concreteValue := valueUnwrapped
	(*x.list)[i] = concreteValue
}

func (x *_TestUpdatedTxRaw_3_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Bytes()
	concreteValue := valueUnwrapped
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestUpdatedTxRaw_3_list) AppendMutable() protoreflect.Value {
	panic(fmt.Errorf("AppendMutable can not be called on message TestUpdatedTxRaw at list field Signatures as it is not of Message kind"))
}

func (x *_TestUpdatedTxRaw_3_list) Truncate(n int) {
	*x.list = (*x.list)[:n]
}

func (x *_TestUpdatedTxRaw_3_list) NewElement() protoreflect.Value {
	var v []byte
	return protoreflect.ValueOfBytes(v)
}

func (x *_TestUpdatedTxRaw_3_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestUpdatedTxRaw                 protoreflect.MessageDescriptor
	fd_TestUpdatedTxRaw_body_bytes      protoreflect.FieldDescriptor
	fd_TestUpdatedTxRaw_auth_info_bytes protoreflect.FieldDescriptor
	fd_TestUpdatedTxRaw_signatures      protoreflect.FieldDescriptor
	fd_TestUpdatedTxRaw_new_field_5     protoreflect.FieldDescriptor
	fd_TestUpdatedTxRaw_new_field_1024  protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestUpdatedTxRaw = File_testpb_unknonwnproto_proto.Messages().ByName("TestUpdatedTxRaw")
	fd_TestUpdatedTxRaw_body_bytes = md_TestUpdatedTxRaw.Fields().ByName("body_bytes")
	fd_TestUpdatedTxRaw_auth_info_bytes = md_TestUpdatedTxRaw.Fields().ByName("auth_info_bytes")
	fd_TestUpdatedTxRaw_signatures = md_TestUpdatedTxRaw.Fields().ByName("signatures")
	fd_TestUpdatedTxRaw_new_field_5 = md_TestUpdatedTxRaw.Fields().ByName("new_field_5")
	fd_TestUpdatedTxRaw_new_field_1024 = md_TestUpdatedTxRaw.Fields().ByName("new_field_1024")
}

var _ protoreflect.Message = (*fastReflection_TestUpdatedTxRaw)(nil)

type fastReflection_TestUpdatedTxRaw TestUpdatedTxRaw

func (x *TestUpdatedTxRaw) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestUpdatedTxRaw)(x)
}

func (x *TestUpdatedTxRaw) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[20]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestUpdatedTxRaw_messageType fastReflection_TestUpdatedTxRaw_messageType
var _ protoreflect.MessageType = fastReflection_TestUpdatedTxRaw_messageType{}

type fastReflection_TestUpdatedTxRaw_messageType struct{}

func (x fastReflection_TestUpdatedTxRaw_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestUpdatedTxRaw)(nil)
}
func (x fastReflection_TestUpdatedTxRaw_messageType) New() protoreflect.Message {
	return new(fastReflection_TestUpdatedTxRaw)
}
func (x fastReflection_TestUpdatedTxRaw_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestUpdatedTxRaw
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestUpdatedTxRaw) Descriptor() protoreflect.MessageDescriptor {
	return md_TestUpdatedTxRaw
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestUpdatedTxRaw) Type() protoreflect.MessageType {
	return _fastReflection_TestUpdatedTxRaw_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestUpdatedTxRaw) New() protoreflect.Message {
	return new(fastReflection_TestUpdatedTxRaw)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestUpdatedTxRaw) Interface() protoreflect.ProtoMessage {
	return (*TestUpdatedTxRaw)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestUpdatedTxRaw) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if len(x.BodyBytes) != 0 {
		value := protoreflect.ValueOfBytes(x.BodyBytes)
		if !f(fd_TestUpdatedTxRaw_body_bytes, value) {
			return
		}
	}
	if len(x.AuthInfoBytes) != 0 {
		value := protoreflect.ValueOfBytes(x.AuthInfoBytes)
		if !f(fd_TestUpdatedTxRaw_auth_info_bytes, value) {
			return
		}
	}
	if len(x.Signatures) != 0 {
		value := protoreflect.ValueOfList(&_TestUpdatedTxRaw_3_list{list: &x.Signatures})
		if !f(fd_TestUpdatedTxRaw_signatures, value) {
			return
		}
	}
	if len(x.NewField_5) != 0 {
		value := protoreflect.ValueOfBytes(x.NewField_5)
		if !f(fd_TestUpdatedTxRaw_new_field_5, value) {
			return
		}
	}
	if len(x.NewField_1024) != 0 {
		value := protoreflect.ValueOfBytes(x.NewField_1024)
		if !f(fd_TestUpdatedTxRaw_new_field_1024, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestUpdatedTxRaw) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxRaw.body_bytes":
		return len(x.BodyBytes) != 0
	case "testpb.TestUpdatedTxRaw.auth_info_bytes":
		return len(x.AuthInfoBytes) != 0
	case "testpb.TestUpdatedTxRaw.signatures":
		return len(x.Signatures) != 0
	case "testpb.TestUpdatedTxRaw.new_field_5":
		return len(x.NewField_5) != 0
	case "testpb.TestUpdatedTxRaw.new_field_1024":
		return len(x.NewField_1024) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxRaw) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxRaw.body_bytes":
		x.BodyBytes = nil
	case "testpb.TestUpdatedTxRaw.auth_info_bytes":
		x.AuthInfoBytes = nil
	case "testpb.TestUpdatedTxRaw.signatures":
		x.Signatures = nil
	case "testpb.TestUpdatedTxRaw.new_field_5":
		x.NewField_5 = nil
	case "testpb.TestUpdatedTxRaw.new_field_1024":
		x.NewField_1024 = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestUpdatedTxRaw) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestUpdatedTxRaw.body_bytes":
		value := x.BodyBytes
		return protoreflect.ValueOfBytes(value)
	case "testpb.TestUpdatedTxRaw.auth_info_bytes":
		value := x.AuthInfoBytes
		return protoreflect.ValueOfBytes(value)
	case "testpb.TestUpdatedTxRaw.signatures":
		if len(x.Signatures) == 0 {
			return protoreflect.ValueOfList(&_TestUpdatedTxRaw_3_list{})
		}
		listValue := &_TestUpdatedTxRaw_3_list{list: &x.Signatures}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestUpdatedTxRaw.new_field_5":
		value := x.NewField_5
		return protoreflect.ValueOfBytes(value)
	case "testpb.TestUpdatedTxRaw.new_field_1024":
		value := x.NewField_1024
		return protoreflect.ValueOfBytes(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxRaw) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxRaw.body_bytes":
		x.BodyBytes = value.Bytes()
	case "testpb.TestUpdatedTxRaw.auth_info_bytes":
		x.AuthInfoBytes = value.Bytes()
	case "testpb.TestUpdatedTxRaw.signatures":
		lv := value.List()
		clv := lv.(*_TestUpdatedTxRaw_3_list)
		x.Signatures = *clv.list
	case "testpb.TestUpdatedTxRaw.new_field_5":
		x.NewField_5 = value.Bytes()
	case "testpb.TestUpdatedTxRaw.new_field_1024":
		x.NewField_1024 = value.Bytes()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxRaw) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxRaw.signatures":
		if x.Signatures == nil {
			x.Signatures = [][]byte{}
		}
		value := &_TestUpdatedTxRaw_3_list{list: &x.Signatures}
		return protoreflect.ValueOfList(value)
	case "testpb.TestUpdatedTxRaw.body_bytes":
		panic(fmt.Errorf("field body_bytes of message testpb.TestUpdatedTxRaw is not mutable"))
	case "testpb.TestUpdatedTxRaw.auth_info_bytes":
		panic(fmt.Errorf("field auth_info_bytes of message testpb.TestUpdatedTxRaw is not mutable"))
	case "testpb.TestUpdatedTxRaw.new_field_5":
		panic(fmt.Errorf("field new_field_5 of message testpb.TestUpdatedTxRaw is not mutable"))
	case "testpb.TestUpdatedTxRaw.new_field_1024":
		panic(fmt.Errorf("field new_field_1024 of message testpb.TestUpdatedTxRaw is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestUpdatedTxRaw) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxRaw.body_bytes":
		return protoreflect.ValueOfBytes(nil)
	case "testpb.TestUpdatedTxRaw.auth_info_bytes":
		return protoreflect.ValueOfBytes(nil)
	case "testpb.TestUpdatedTxRaw.signatures":
		list := [][]byte{}
		return protoreflect.ValueOfList(&_TestUpdatedTxRaw_3_list{list: &list})
	case "testpb.TestUpdatedTxRaw.new_field_5":
		return protoreflect.ValueOfBytes(nil)
	case "testpb.TestUpdatedTxRaw.new_field_1024":
		return protoreflect.ValueOfBytes(nil)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxRaw"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxRaw does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestUpdatedTxRaw) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestUpdatedTxRaw", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestUpdatedTxRaw) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxRaw) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestUpdatedTxRaw) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestUpdatedTxRaw) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestUpdatedTxRaw)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		l = len(x.BodyBytes)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.AuthInfoBytes)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if len(x.Signatures) > 0 {
			for _, b := range x.Signatures {
				l = len(b)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		l = len(x.NewField_5)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.NewField_1024)
		if l > 0 {
			n += 2 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestUpdatedTxRaw)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.NewField_1024) > 0 {
			i -= len(x.NewField_1024)
			copy(dAtA[i:], x.NewField_1024)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_1024)))
			i--
			dAtA[i] = 0x40
			i--
			dAtA[i] = 0x82
		}
		if len(x.NewField_5) > 0 {
			i -= len(x.NewField_5)
			copy(dAtA[i:], x.NewField_5)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_5)))
			i--
			dAtA[i] = 0x2a
		}
		if len(x.Signatures) > 0 {
			for iNdEx := len(x.Signatures) - 1; iNdEx >= 0; iNdEx-- {
				i -= len(x.Signatures[iNdEx])
				copy(dAtA[i:], x.Signatures[iNdEx])
				i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signatures[iNdEx])))
				i--
				dAtA[i] = 0x1a
			}
		}
		if len(x.AuthInfoBytes) > 0 {
			i -= len(x.AuthInfoBytes)
			copy(dAtA[i:], x.AuthInfoBytes)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.AuthInfoBytes)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.BodyBytes) > 0 {
			i -= len(x.BodyBytes)
			copy(dAtA[i:], x.BodyBytes)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.BodyBytes)))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestUpdatedTxRaw)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxRaw: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxRaw: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field BodyBytes", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.BodyBytes = append(x.BodyBytes[:0], dAtA[iNdEx:postIndex]...)
				if x.BodyBytes == nil {
					x.BodyBytes = []byte{}
				}
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field AuthInfoBytes", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.AuthInfoBytes = append(x.AuthInfoBytes[:0], dAtA[iNdEx:postIndex]...)
				if x.AuthInfoBytes == nil {
					x.AuthInfoBytes = []byte{}
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Signatures = append(x.Signatures, make([]byte, postIndex-iNdEx))
				copy(x.Signatures[len(x.Signatures)-1], dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 5:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_5", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NewField_5 = append(x.NewField_5[:0], dAtA[iNdEx:postIndex]...)
				if x.NewField_5 == nil {
					x.NewField_5 = []byte{}
				}
				iNdEx = postIndex
			case 1024:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_1024", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NewField_1024 = append(x.NewField_1024[:0], dAtA[iNdEx:postIndex]...)
				if x.NewField_1024 == nil {
					x.NewField_1024 = []byte{}
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestUpdatedTxBody_1_list)(nil)

type _TestUpdatedTxBody_1_list struct {
	list *[]*anypb.Any
}

func (x *_TestUpdatedTxBody_1_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestUpdatedTxBody_1_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestUpdatedTxBody_1_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*anypb.Any)
	(*x.list)[i] = concreteValue
}

func (x *_TestUpdatedTxBody_1_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*anypb.Any)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestUpdatedTxBody_1_list) AppendMutable() protoreflect.Value {
	v := new(anypb.Any)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedTxBody_1_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestUpdatedTxBody_1_list) NewElement() protoreflect.Value {
	v := new(anypb.Any)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedTxBody_1_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestUpdatedTxBody_1023_list)(nil)

type _TestUpdatedTxBody_1023_list struct {
	list *[]*anypb.Any
}

func (x *_TestUpdatedTxBody_1023_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestUpdatedTxBody_1023_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestUpdatedTxBody_1023_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*anypb.Any)
	(*x.list)[i] = concreteValue
}

func (x *_TestUpdatedTxBody_1023_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*anypb.Any)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestUpdatedTxBody_1023_list) AppendMutable() protoreflect.Value {
	v := new(anypb.Any)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedTxBody_1023_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestUpdatedTxBody_1023_list) NewElement() protoreflect.Value {
	v := new(anypb.Any)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedTxBody_1023_list) IsValid() bool {
	return x.list != nil
}

var _ protoreflect.List = (*_TestUpdatedTxBody_2047_list)(nil)

type _TestUpdatedTxBody_2047_list struct {
	list *[]*anypb.Any
}

func (x *_TestUpdatedTxBody_2047_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestUpdatedTxBody_2047_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestUpdatedTxBody_2047_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*anypb.Any)
	(*x.list)[i] = concreteValue
}

func (x *_TestUpdatedTxBody_2047_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*anypb.Any)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestUpdatedTxBody_2047_list) AppendMutable() protoreflect.Value {
	v := new(anypb.Any)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedTxBody_2047_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestUpdatedTxBody_2047_list) NewElement() protoreflect.Value {
	v := new(anypb.Any)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedTxBody_2047_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestUpdatedTxBody                                   protoreflect.MessageDescriptor
	fd_TestUpdatedTxBody_messages                          protoreflect.FieldDescriptor
	fd_TestUpdatedTxBody_memo                              protoreflect.FieldDescriptor
	fd_TestUpdatedTxBody_timeout_height                    protoreflect.FieldDescriptor
	fd_TestUpdatedTxBody_some_new_field                    protoreflect.FieldDescriptor
	fd_TestUpdatedTxBody_some_new_field_non_critical_field protoreflect.FieldDescriptor
	fd_TestUpdatedTxBody_extension_options                 protoreflect.FieldDescriptor
	fd_TestUpdatedTxBody_non_critical_extension_options    protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestUpdatedTxBody = File_testpb_unknonwnproto_proto.Messages().ByName("TestUpdatedTxBody")
	fd_TestUpdatedTxBody_messages = md_TestUpdatedTxBody.Fields().ByName("messages")
	fd_TestUpdatedTxBody_memo = md_TestUpdatedTxBody.Fields().ByName("memo")
	fd_TestUpdatedTxBody_timeout_height = md_TestUpdatedTxBody.Fields().ByName("timeout_height")
	fd_TestUpdatedTxBody_some_new_field = md_TestUpdatedTxBody.Fields().ByName("some_new_field")
	fd_TestUpdatedTxBody_some_new_field_non_critical_field = md_TestUpdatedTxBody.Fields().ByName("some_new_field_non_critical_field")
	fd_TestUpdatedTxBody_extension_options = md_TestUpdatedTxBody.Fields().ByName("extension_options")
	fd_TestUpdatedTxBody_non_critical_extension_options = md_TestUpdatedTxBody.Fields().ByName("non_critical_extension_options")
}

var _ protoreflect.Message = (*fastReflection_TestUpdatedTxBody)(nil)

type fastReflection_TestUpdatedTxBody TestUpdatedTxBody

func (x *TestUpdatedTxBody) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestUpdatedTxBody)(x)
}

func (x *TestUpdatedTxBody) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[21]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestUpdatedTxBody_messageType fastReflection_TestUpdatedTxBody_messageType
var _ protoreflect.MessageType = fastReflection_TestUpdatedTxBody_messageType{}

type fastReflection_TestUpdatedTxBody_messageType struct{}

func (x fastReflection_TestUpdatedTxBody_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestUpdatedTxBody)(nil)
}
func (x fastReflection_TestUpdatedTxBody_messageType) New() protoreflect.Message {
	return new(fastReflection_TestUpdatedTxBody)
}
func (x fastReflection_TestUpdatedTxBody_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestUpdatedTxBody
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestUpdatedTxBody) Descriptor() protoreflect.MessageDescriptor {
	return md_TestUpdatedTxBody
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestUpdatedTxBody) Type() protoreflect.MessageType {
	return _fastReflection_TestUpdatedTxBody_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestUpdatedTxBody) New() protoreflect.Message {
	return new(fastReflection_TestUpdatedTxBody)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestUpdatedTxBody) Interface() protoreflect.ProtoMessage {
	return (*TestUpdatedTxBody)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestUpdatedTxBody) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if len(x.Messages) != 0 {
		value := protoreflect.ValueOfList(&_TestUpdatedTxBody_1_list{list: &x.Messages})
		if !f(fd_TestUpdatedTxBody_messages, value) {
			return
		}
	}
	if x.Memo != "" {
		value := protoreflect.ValueOfString(x.Memo)
		if !f(fd_TestUpdatedTxBody_memo, value) {
			return
		}
	}
	if x.TimeoutHeight != int64(0) {
		value := protoreflect.ValueOfInt64(x.TimeoutHeight)
		if !f(fd_TestUpdatedTxBody_timeout_height, value) {
			return
		}
	}
	if x.SomeNewField != uint64(0) {
		value := protoreflect.ValueOfUint64(x.SomeNewField)
		if !f(fd_TestUpdatedTxBody_some_new_field, value) {
			return
		}
	}
	if x.SomeNewFieldNonCriticalField != "" {
		value := protoreflect.ValueOfString(x.SomeNewFieldNonCriticalField)
		if !f(fd_TestUpdatedTxBody_some_new_field_non_critical_field, value) {
			return
		}
	}
	if len(x.ExtensionOptions) != 0 {
		value := protoreflect.ValueOfList(&_TestUpdatedTxBody_1023_list{list: &x.ExtensionOptions})
		if !f(fd_TestUpdatedTxBody_extension_options, value) {
			return
		}
	}
	if len(x.NonCriticalExtensionOptions) != 0 {
		value := protoreflect.ValueOfList(&_TestUpdatedTxBody_2047_list{list: &x.NonCriticalExtensionOptions})
		if !f(fd_TestUpdatedTxBody_non_critical_extension_options, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestUpdatedTxBody) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxBody.messages":
		return len(x.Messages) != 0
	case "testpb.TestUpdatedTxBody.memo":
		return x.Memo != ""
	case "testpb.TestUpdatedTxBody.timeout_height":
		return x.TimeoutHeight != int64(0)
	case "testpb.TestUpdatedTxBody.some_new_field":
		return x.SomeNewField != uint64(0)
	case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field":
		return x.SomeNewFieldNonCriticalField != ""
	case "testpb.TestUpdatedTxBody.extension_options":
		return len(x.ExtensionOptions) != 0
	case "testpb.TestUpdatedTxBody.non_critical_extension_options":
		return len(x.NonCriticalExtensionOptions) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxBody) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxBody.messages":
		x.Messages = nil
	case "testpb.TestUpdatedTxBody.memo":
		x.Memo = ""
	case "testpb.TestUpdatedTxBody.timeout_height":
		x.TimeoutHeight = int64(0)
	case "testpb.TestUpdatedTxBody.some_new_field":
		x.SomeNewField = uint64(0)
	case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field":
		x.SomeNewFieldNonCriticalField = ""
	case "testpb.TestUpdatedTxBody.extension_options":
		x.ExtensionOptions = nil
	case "testpb.TestUpdatedTxBody.non_critical_extension_options":
		x.NonCriticalExtensionOptions = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestUpdatedTxBody) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestUpdatedTxBody.messages":
		if len(x.Messages) == 0 {
			return protoreflect.ValueOfList(&_TestUpdatedTxBody_1_list{})
		}
		listValue := &_TestUpdatedTxBody_1_list{list: &x.Messages}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestUpdatedTxBody.memo":
		value := x.Memo
		return protoreflect.ValueOfString(value)
	case "testpb.TestUpdatedTxBody.timeout_height":
		value := x.TimeoutHeight
		return protoreflect.ValueOfInt64(value)
	case "testpb.TestUpdatedTxBody.some_new_field":
		value := x.SomeNewField
		return protoreflect.ValueOfUint64(value)
	case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field":
		value := x.SomeNewFieldNonCriticalField
		return protoreflect.ValueOfString(value)
	case "testpb.TestUpdatedTxBody.extension_options":
		if len(x.ExtensionOptions) == 0 {
			return protoreflect.ValueOfList(&_TestUpdatedTxBody_1023_list{})
		}
		listValue := &_TestUpdatedTxBody_1023_list{list: &x.ExtensionOptions}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestUpdatedTxBody.non_critical_extension_options":
		if len(x.NonCriticalExtensionOptions) == 0 {
			return protoreflect.ValueOfList(&_TestUpdatedTxBody_2047_list{})
		}
		listValue := &_TestUpdatedTxBody_2047_list{list: &x.NonCriticalExtensionOptions}
		return protoreflect.ValueOfList(listValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxBody) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxBody.messages":
		lv := value.List()
		clv := lv.(*_TestUpdatedTxBody_1_list)
		x.Messages = *clv.list
	case "testpb.TestUpdatedTxBody.memo":
		x.Memo = value.Interface().(string)
	case "testpb.TestUpdatedTxBody.timeout_height":
		x.TimeoutHeight = value.Int()
	case "testpb.TestUpdatedTxBody.some_new_field":
		x.SomeNewField = value.Uint()
	case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field":
		x.SomeNewFieldNonCriticalField = value.Interface().(string)
	case "testpb.TestUpdatedTxBody.extension_options":
		lv := value.List()
		clv := lv.(*_TestUpdatedTxBody_1023_list)
		x.ExtensionOptions = *clv.list
	case "testpb.TestUpdatedTxBody.non_critical_extension_options":
		lv := value.List()
		clv := lv.(*_TestUpdatedTxBody_2047_list)
		x.NonCriticalExtensionOptions = *clv.list
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxBody) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxBody.messages":
		if x.Messages == nil {
			x.Messages = []*anypb.Any{}
		}
		value := &_TestUpdatedTxBody_1_list{list: &x.Messages}
		return protoreflect.ValueOfList(value)
	case "testpb.TestUpdatedTxBody.extension_options":
		if x.ExtensionOptions == nil {
			x.ExtensionOptions = []*anypb.Any{}
		}
		value := &_TestUpdatedTxBody_1023_list{list: &x.ExtensionOptions}
		return protoreflect.ValueOfList(value)
	case "testpb.TestUpdatedTxBody.non_critical_extension_options":
		if x.NonCriticalExtensionOptions == nil {
			x.NonCriticalExtensionOptions = []*anypb.Any{}
		}
		value := &_TestUpdatedTxBody_2047_list{list: &x.NonCriticalExtensionOptions}
		return protoreflect.ValueOfList(value)
	case "testpb.TestUpdatedTxBody.memo":
		panic(fmt.Errorf("field memo of message testpb.TestUpdatedTxBody is not mutable"))
	case "testpb.TestUpdatedTxBody.timeout_height":
		panic(fmt.Errorf("field timeout_height of message testpb.TestUpdatedTxBody is not mutable"))
	case "testpb.TestUpdatedTxBody.some_new_field":
		panic(fmt.Errorf("field some_new_field of message testpb.TestUpdatedTxBody is not mutable"))
	case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field":
		panic(fmt.Errorf("field some_new_field_non_critical_field of message testpb.TestUpdatedTxBody is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestUpdatedTxBody) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestUpdatedTxBody.messages":
		list := []*anypb.Any{}
		return protoreflect.ValueOfList(&_TestUpdatedTxBody_1_list{list: &list})
	case "testpb.TestUpdatedTxBody.memo":
		return protoreflect.ValueOfString("")
	case "testpb.TestUpdatedTxBody.timeout_height":
		return protoreflect.ValueOfInt64(int64(0))
	case "testpb.TestUpdatedTxBody.some_new_field":
		return protoreflect.ValueOfUint64(uint64(0))
	case "testpb.TestUpdatedTxBody.some_new_field_non_critical_field":
		return protoreflect.ValueOfString("")
	case "testpb.TestUpdatedTxBody.extension_options":
		list := []*anypb.Any{}
		return protoreflect.ValueOfList(&_TestUpdatedTxBody_1023_list{list: &list})
	case "testpb.TestUpdatedTxBody.non_critical_extension_options":
		list := []*anypb.Any{}
		return protoreflect.ValueOfList(&_TestUpdatedTxBody_2047_list{list: &list})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedTxBody"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedTxBody does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestUpdatedTxBody) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestUpdatedTxBody", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestUpdatedTxBody) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedTxBody) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestUpdatedTxBody) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestUpdatedTxBody) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestUpdatedTxBody)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if len(x.Messages) > 0 {
			for _, e := range x.Messages {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		l = len(x.Memo)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		if x.TimeoutHeight != 0 {
			n += 1 + runtime.Sov(uint64(x.TimeoutHeight))
		}
		if x.SomeNewField != 0 {
			n += 1 + runtime.Sov(uint64(x.SomeNewField))
		}
		l = len(x.SomeNewFieldNonCriticalField)
		if l > 0 {
			n += 2 + l + runtime.Sov(uint64(l))
		}
		if len(x.ExtensionOptions) > 0 {
			for _, e := range x.ExtensionOptions {
				l = options.Size(e)
				n += 2 + l + runtime.Sov(uint64(l))
			}
		}
		if len(x.NonCriticalExtensionOptions) > 0 {
			for _, e := range x.NonCriticalExtensionOptions {
				l = options.Size(e)
				n += 2 + l + runtime.Sov(uint64(l))
			}
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestUpdatedTxBody)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.NonCriticalExtensionOptions) > 0 {
			for iNdEx := len(x.NonCriticalExtensionOptions) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.NonCriticalExtensionOptions[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x7f
				i--
				dAtA[i] = 0xfa
			}
		}
		if len(x.SomeNewFieldNonCriticalField) > 0 {
			i -= len(x.SomeNewFieldNonCriticalField)
			copy(dAtA[i:], x.SomeNewFieldNonCriticalField)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.SomeNewFieldNonCriticalField)))
			i--
			dAtA[i] = 0x41
			i--
			dAtA[i] = 0xd2
		}
		if len(x.ExtensionOptions) > 0 {
			for iNdEx := len(x.ExtensionOptions) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.ExtensionOptions[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0x3f
				i--
				dAtA[i] = 0xfa
			}
		}
		if x.SomeNewField != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.SomeNewField))
			i--
			dAtA[i] = 0x28
		}
		if x.TimeoutHeight != 0 {
			i = runtime.EncodeVarint(dAtA, i, uint64(x.TimeoutHeight))
			i--
			dAtA[i] = 0x18
		}
		if len(x.Memo) > 0 {
			i -= len(x.Memo)
			copy(dAtA[i:], x.Memo)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Memo)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.Messages) > 0 {
			for iNdEx := len(x.Messages) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.Messages[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0xa
			}
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestUpdatedTxBody)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxBody: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedTxBody: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Messages", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Messages = append(x.Messages, &anypb.Any{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Messages[len(x.Messages)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Memo", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.Memo = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 3:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field TimeoutHeight", wireType)
				}
				x.TimeoutHeight = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.TimeoutHeight |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 5:
				if wireType != 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SomeNewField", wireType)
				}
				x.SomeNewField = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					x.SomeNewField |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 1050:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SomeNewFieldNonCriticalField", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SomeNewFieldNonCriticalField = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 1023:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ExtensionOptions", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.ExtensionOptions = append(x.ExtensionOptions, &anypb.Any{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.ExtensionOptions[len(x.ExtensionOptions)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 2047:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NonCriticalExtensionOptions", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NonCriticalExtensionOptions = append(x.NonCriticalExtensionOptions, &anypb.Any{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.NonCriticalExtensionOptions[len(x.NonCriticalExtensionOptions)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestUpdatedAuthInfo_1_list)(nil)

type _TestUpdatedAuthInfo_1_list struct {
	list *[]*v1beta1.SignerInfo
}

func (x *_TestUpdatedAuthInfo_1_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestUpdatedAuthInfo_1_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect())
}

func (x *_TestUpdatedAuthInfo_1_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*v1beta1.SignerInfo)
	(*x.list)[i] = concreteValue
}

func (x *_TestUpdatedAuthInfo_1_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Message()
	concreteValue := valueUnwrapped.Interface().(*v1beta1.SignerInfo)
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestUpdatedAuthInfo_1_list) AppendMutable() protoreflect.Value {
	v := new(v1beta1.SignerInfo)
	*x.list = append(*x.list, v)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedAuthInfo_1_list) Truncate(n int) {
	for i := n; i < len(*x.list); i++ {
		(*x.list)[i] = nil
	}
	*x.list = (*x.list)[:n]
}

func (x *_TestUpdatedAuthInfo_1_list) NewElement() protoreflect.Value {
	v := new(v1beta1.SignerInfo)
	return protoreflect.ValueOfMessage(v.ProtoReflect())
}

func (x *_TestUpdatedAuthInfo_1_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestUpdatedAuthInfo                protoreflect.MessageDescriptor
	fd_TestUpdatedAuthInfo_signer_infos   protoreflect.FieldDescriptor
	fd_TestUpdatedAuthInfo_fee            protoreflect.FieldDescriptor
	fd_TestUpdatedAuthInfo_new_field_3    protoreflect.FieldDescriptor
	fd_TestUpdatedAuthInfo_new_field_1024 protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestUpdatedAuthInfo = File_testpb_unknonwnproto_proto.Messages().ByName("TestUpdatedAuthInfo")
	fd_TestUpdatedAuthInfo_signer_infos = md_TestUpdatedAuthInfo.Fields().ByName("signer_infos")
	fd_TestUpdatedAuthInfo_fee = md_TestUpdatedAuthInfo.Fields().ByName("fee")
	fd_TestUpdatedAuthInfo_new_field_3 = md_TestUpdatedAuthInfo.Fields().ByName("new_field_3")
	fd_TestUpdatedAuthInfo_new_field_1024 = md_TestUpdatedAuthInfo.Fields().ByName("new_field_1024")
}

var _ protoreflect.Message = (*fastReflection_TestUpdatedAuthInfo)(nil)

type fastReflection_TestUpdatedAuthInfo TestUpdatedAuthInfo

func (x *TestUpdatedAuthInfo) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestUpdatedAuthInfo)(x)
}

func (x *TestUpdatedAuthInfo) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[22]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestUpdatedAuthInfo_messageType fastReflection_TestUpdatedAuthInfo_messageType
var _ protoreflect.MessageType = fastReflection_TestUpdatedAuthInfo_messageType{}

type fastReflection_TestUpdatedAuthInfo_messageType struct{}

func (x fastReflection_TestUpdatedAuthInfo_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestUpdatedAuthInfo)(nil)
}
func (x fastReflection_TestUpdatedAuthInfo_messageType) New() protoreflect.Message {
	return new(fastReflection_TestUpdatedAuthInfo)
}
func (x fastReflection_TestUpdatedAuthInfo_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestUpdatedAuthInfo
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestUpdatedAuthInfo) Descriptor() protoreflect.MessageDescriptor {
	return md_TestUpdatedAuthInfo
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestUpdatedAuthInfo) Type() protoreflect.MessageType {
	return _fastReflection_TestUpdatedAuthInfo_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestUpdatedAuthInfo) New() protoreflect.Message {
	return new(fastReflection_TestUpdatedAuthInfo)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestUpdatedAuthInfo) Interface() protoreflect.ProtoMessage {
	return (*TestUpdatedAuthInfo)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestUpdatedAuthInfo) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if len(x.SignerInfos) != 0 {
		value := protoreflect.ValueOfList(&_TestUpdatedAuthInfo_1_list{list: &x.SignerInfos})
		if !f(fd_TestUpdatedAuthInfo_signer_infos, value) {
			return
		}
	}
	if x.Fee != nil {
		value := protoreflect.ValueOfMessage(x.Fee.ProtoReflect())
		if !f(fd_TestUpdatedAuthInfo_fee, value) {
			return
		}
	}
	if len(x.NewField_3) != 0 {
		value := protoreflect.ValueOfBytes(x.NewField_3)
		if !f(fd_TestUpdatedAuthInfo_new_field_3, value) {
			return
		}
	}
	if len(x.NewField_1024) != 0 {
		value := protoreflect.ValueOfBytes(x.NewField_1024)
		if !f(fd_TestUpdatedAuthInfo_new_field_1024, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestUpdatedAuthInfo) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestUpdatedAuthInfo.signer_infos":
		return len(x.SignerInfos) != 0
	case "testpb.TestUpdatedAuthInfo.fee":
		return x.Fee != nil
	case "testpb.TestUpdatedAuthInfo.new_field_3":
		return len(x.NewField_3) != 0
	case "testpb.TestUpdatedAuthInfo.new_field_1024":
		return len(x.NewField_1024) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedAuthInfo) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestUpdatedAuthInfo.signer_infos":
		x.SignerInfos = nil
	case "testpb.TestUpdatedAuthInfo.fee":
		x.Fee = nil
	case "testpb.TestUpdatedAuthInfo.new_field_3":
		x.NewField_3 = nil
	case "testpb.TestUpdatedAuthInfo.new_field_1024":
		x.NewField_1024 = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestUpdatedAuthInfo) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestUpdatedAuthInfo.signer_infos":
		if len(x.SignerInfos) == 0 {
			return protoreflect.ValueOfList(&_TestUpdatedAuthInfo_1_list{})
		}
		listValue := &_TestUpdatedAuthInfo_1_list{list: &x.SignerInfos}
		return protoreflect.ValueOfList(listValue)
	case "testpb.TestUpdatedAuthInfo.fee":
		value := x.Fee
		return protoreflect.ValueOfMessage(value.ProtoReflect())
	case "testpb.TestUpdatedAuthInfo.new_field_3":
		value := x.NewField_3
		return protoreflect.ValueOfBytes(value)
	case "testpb.TestUpdatedAuthInfo.new_field_1024":
		value := x.NewField_1024
		return protoreflect.ValueOfBytes(value)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedAuthInfo) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestUpdatedAuthInfo.signer_infos":
		lv := value.List()
		clv := lv.(*_TestUpdatedAuthInfo_1_list)
		x.SignerInfos = *clv.list
	case "testpb.TestUpdatedAuthInfo.fee":
		x.Fee = value.Message().Interface().(*v1beta1.Fee)
	case "testpb.TestUpdatedAuthInfo.new_field_3":
		x.NewField_3 = value.Bytes()
	case "testpb.TestUpdatedAuthInfo.new_field_1024":
		x.NewField_1024 = value.Bytes()
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedAuthInfo) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestUpdatedAuthInfo.signer_infos":
		if x.SignerInfos == nil {
			x.SignerInfos = []*v1beta1.SignerInfo{}
		}
		value := &_TestUpdatedAuthInfo_1_list{list: &x.SignerInfos}
		return protoreflect.ValueOfList(value)
	case "testpb.TestUpdatedAuthInfo.fee":
		if x.Fee == nil {
			x.Fee = new(v1beta1.Fee)
		}
		return protoreflect.ValueOfMessage(x.Fee.ProtoReflect())
	case "testpb.TestUpdatedAuthInfo.new_field_3":
		panic(fmt.Errorf("field new_field_3 of message testpb.TestUpdatedAuthInfo is not mutable"))
	case "testpb.TestUpdatedAuthInfo.new_field_1024":
		panic(fmt.Errorf("field new_field_1024 of message testpb.TestUpdatedAuthInfo is not mutable"))
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestUpdatedAuthInfo) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestUpdatedAuthInfo.signer_infos":
		list := []*v1beta1.SignerInfo{}
		return protoreflect.ValueOfList(&_TestUpdatedAuthInfo_1_list{list: &list})
	case "testpb.TestUpdatedAuthInfo.fee":
		m := new(v1beta1.Fee)
		return protoreflect.ValueOfMessage(m.ProtoReflect())
	case "testpb.TestUpdatedAuthInfo.new_field_3":
		return protoreflect.ValueOfBytes(nil)
	case "testpb.TestUpdatedAuthInfo.new_field_1024":
		return protoreflect.ValueOfBytes(nil)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestUpdatedAuthInfo"))
		}
		panic(fmt.Errorf("message testpb.TestUpdatedAuthInfo does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestUpdatedAuthInfo) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestUpdatedAuthInfo", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestUpdatedAuthInfo) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestUpdatedAuthInfo) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestUpdatedAuthInfo) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestUpdatedAuthInfo) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestUpdatedAuthInfo)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if len(x.SignerInfos) > 0 {
			for _, e := range x.SignerInfos {
				l = options.Size(e)
				n += 1 + l + runtime.Sov(uint64(l))
			}
		}
		if x.Fee != nil {
			l = options.Size(x.Fee)
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.NewField_3)
		if l > 0 {
			n += 1 + l + runtime.Sov(uint64(l))
		}
		l = len(x.NewField_1024)
		if l > 0 {
			n += 2 + l + runtime.Sov(uint64(l))
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestUpdatedAuthInfo)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.NewField_1024) > 0 {
			i -= len(x.NewField_1024)
			copy(dAtA[i:], x.NewField_1024)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_1024)))
			i--
			dAtA[i] = 0x40
			i--
			dAtA[i] = 0x82
		}
		if len(x.NewField_3) > 0 {
			i -= len(x.NewField_3)
			copy(dAtA[i:], x.NewField_3)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(x.NewField_3)))
			i--
			dAtA[i] = 0x1a
		}
		if x.Fee != nil {
			encoded, err := options.Marshal(x.Fee)
			if err != nil {
				return protoiface.MarshalOutput{
					NoUnkeyedLiterals: input.NoUnkeyedLiterals,
					Buf:               input.Buf,
				}, err
			}
			i -= len(encoded)
			copy(dAtA[i:], encoded)
			i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
			i--
			dAtA[i] = 0x12
		}
		if len(x.SignerInfos) > 0 {
			for iNdEx := len(x.SignerInfos) - 1; iNdEx >= 0; iNdEx-- {
				encoded, err := options.Marshal(x.SignerInfos[iNdEx])
				if err != nil {
					return protoiface.MarshalOutput{
						NoUnkeyedLiterals: input.NoUnkeyedLiterals,
						Buf:               input.Buf,
					}, err
				}
				i -= len(encoded)
				copy(dAtA[i:], encoded)
				i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded)))
				i--
				dAtA[i] = 0xa
			}
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestUpdatedAuthInfo)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedAuthInfo: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestUpdatedAuthInfo: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field SignerInfos", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.SignerInfos = append(x.SignerInfos, &v1beta1.SignerInfo{})
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.SignerInfos[len(x.SignerInfos)-1]); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 2:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Fee", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if x.Fee == nil {
					x.Fee = &v1beta1.Fee{}
				}
				if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Fee); err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				iNdEx = postIndex
			case 3:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_3", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NewField_3 = append(x.NewField_3[:0], dAtA[iNdEx:postIndex]...)
				if x.NewField_3 == nil {
					x.NewField_3 = []byte{}
				}
				iNdEx = postIndex
			case 1024:
				if wireType != 2 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field NewField_1024", wireType)
				}
				var byteLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
					}
					if iNdEx >= l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					byteLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if byteLen < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				postIndex := iNdEx + byteLen
				if postIndex < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if postIndex > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				x.NewField_1024 = append(x.NewField_1024[:0], dAtA[iNdEx:postIndex]...)
				if x.NewField_1024 == nil {
					x.NewField_1024 = []byte{}
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

var _ protoreflect.List = (*_TestRepeatedUints_1_list)(nil)

type _TestRepeatedUints_1_list struct {
	list *[]uint64
}

func (x *_TestRepeatedUints_1_list) Len() int {
	if x.list == nil {
		return 0
	}
	return len(*x.list)
}

func (x *_TestRepeatedUints_1_list) Get(i int) protoreflect.Value {
	return protoreflect.ValueOfUint64((*x.list)[i])
}

func (x *_TestRepeatedUints_1_list) Set(i int, value protoreflect.Value) {
	valueUnwrapped := value.Uint()
	concreteValue := valueUnwrapped
	(*x.list)[i] = concreteValue
}

func (x *_TestRepeatedUints_1_list) Append(value protoreflect.Value) {
	valueUnwrapped := value.Uint()
	concreteValue := valueUnwrapped
	*x.list = append(*x.list, concreteValue)
}

func (x *_TestRepeatedUints_1_list) AppendMutable() protoreflect.Value {
	panic(fmt.Errorf("AppendMutable can not be called on message TestRepeatedUints at list field Nums as it is not of Message kind"))
}

func (x *_TestRepeatedUints_1_list) Truncate(n int) {
	*x.list = (*x.list)[:n]
}

func (x *_TestRepeatedUints_1_list) NewElement() protoreflect.Value {
	v := uint64(0)
	return protoreflect.ValueOfUint64(v)
}

func (x *_TestRepeatedUints_1_list) IsValid() bool {
	return x.list != nil
}

var (
	md_TestRepeatedUints      protoreflect.MessageDescriptor
	fd_TestRepeatedUints_nums protoreflect.FieldDescriptor
)

func init() {
	file_testpb_unknonwnproto_proto_init()
	md_TestRepeatedUints = File_testpb_unknonwnproto_proto.Messages().ByName("TestRepeatedUints")
	fd_TestRepeatedUints_nums = md_TestRepeatedUints.Fields().ByName("nums")
}

var _ protoreflect.Message = (*fastReflection_TestRepeatedUints)(nil)

type fastReflection_TestRepeatedUints TestRepeatedUints

func (x *TestRepeatedUints) ProtoReflect() protoreflect.Message {
	return (*fastReflection_TestRepeatedUints)(x)
}

func (x *TestRepeatedUints) slowProtoReflect() protoreflect.Message {
	mi := &file_testpb_unknonwnproto_proto_msgTypes[23]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

var _fastReflection_TestRepeatedUints_messageType fastReflection_TestRepeatedUints_messageType
var _ protoreflect.MessageType = fastReflection_TestRepeatedUints_messageType{}

type fastReflection_TestRepeatedUints_messageType struct{}

func (x fastReflection_TestRepeatedUints_messageType) Zero() protoreflect.Message {
	return (*fastReflection_TestRepeatedUints)(nil)
}
func (x fastReflection_TestRepeatedUints_messageType) New() protoreflect.Message {
	return new(fastReflection_TestRepeatedUints)
}
func (x fastReflection_TestRepeatedUints_messageType) Descriptor() protoreflect.MessageDescriptor {
	return md_TestRepeatedUints
}

// Descriptor returns message descriptor, which contains only the protobuf
// type information for the message.
func (x *fastReflection_TestRepeatedUints) Descriptor() protoreflect.MessageDescriptor {
	return md_TestRepeatedUints
}

// Type returns the message type, which encapsulates both Go and protobuf
// type information. If the Go type information is not needed,
// it is recommended that the message descriptor be used instead.
func (x *fastReflection_TestRepeatedUints) Type() protoreflect.MessageType {
	return _fastReflection_TestRepeatedUints_messageType
}

// New returns a newly allocated and mutable empty message.
func (x *fastReflection_TestRepeatedUints) New() protoreflect.Message {
	return new(fastReflection_TestRepeatedUints)
}

// Interface unwraps the message reflection interface and
// returns the underlying ProtoMessage interface.
func (x *fastReflection_TestRepeatedUints) Interface() protoreflect.ProtoMessage {
	return (*TestRepeatedUints)(x)
}

// Range iterates over every populated field in an undefined order,
// calling f for each field descriptor and value encountered.
// Range returns immediately if f returns false.
// While iterating, mutating operations may only be performed
// on the current field descriptor.
func (x *fastReflection_TestRepeatedUints) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	if len(x.Nums) != 0 {
		value := protoreflect.ValueOfList(&_TestRepeatedUints_1_list{list: &x.Nums})
		if !f(fd_TestRepeatedUints_nums, value) {
			return
		}
	}
}

// Has reports whether a field is populated.
//
// Some fields have the property of nullability where it is possible to
// distinguish between the default value of a field and whether the field
// was explicitly populated with the default value. Singular message fields,
// member fields of a oneof, and proto2 scalar fields are nullable. Such
// fields are populated only if explicitly set.
//
// In other cases (aside from the nullable cases above),
// a proto3 scalar field is populated if it contains a non-zero value, and
// a repeated field is populated if it is non-empty.
func (x *fastReflection_TestRepeatedUints) Has(fd protoreflect.FieldDescriptor) bool {
	switch fd.FullName() {
	case "testpb.TestRepeatedUints.nums":
		return len(x.Nums) != 0
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints"))
		}
		panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName()))
	}
}

// Clear clears the field such that a subsequent Has call reports false.
//
// Clearing an extension field clears both the extension type and value
// associated with the given field number.
//
// Clear is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestRepeatedUints) Clear(fd protoreflect.FieldDescriptor) {
	switch fd.FullName() {
	case "testpb.TestRepeatedUints.nums":
		x.Nums = nil
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints"))
		}
		panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName()))
	}
}

// Get retrieves the value for a field.
//
// For unpopulated scalars, it returns the default value, where
// the default value of a bytes scalar is guaranteed to be a copy.
// For unpopulated composite types, it returns an empty, read-only view
// of the value; to obtain a mutable reference, use Mutable.
func (x *fastReflection_TestRepeatedUints) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value {
	switch descriptor.FullName() {
	case "testpb.TestRepeatedUints.nums":
		if len(x.Nums) == 0 {
			return protoreflect.ValueOfList(&_TestRepeatedUints_1_list{})
		}
		listValue := &_TestRepeatedUints_1_list{list: &x.Nums}
		return protoreflect.ValueOfList(listValue)
	default:
		if descriptor.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints"))
		}
		panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", descriptor.FullName()))
	}
}

// Set stores the value for a field.
//
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType.
// When setting a composite type, it is unspecified whether the stored value
// aliases the source's memory in any way. If the composite value is an
// empty, read-only value, then it panics.
//
// Set is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestRepeatedUints) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) {
	switch fd.FullName() {
	case "testpb.TestRepeatedUints.nums":
		lv := value.List()
		clv := lv.(*_TestRepeatedUints_1_list)
		x.Nums = *clv.list
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints"))
		}
		panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName()))
	}
}

// Mutable returns a mutable reference to a composite type.
//
// If the field is unpopulated, it may allocate a composite value.
// For a field belonging to a oneof, it implicitly clears any other field
// that may be currently set within the same oneof.
// For extension fields, it implicitly stores the provided ExtensionType
// if not already stored.
// It panics if the field does not contain a composite type.
//
// Mutable is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestRepeatedUints) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestRepeatedUints.nums":
		if x.Nums == nil {
			x.Nums = []uint64{}
		}
		value := &_TestRepeatedUints_1_list{list: &x.Nums}
		return protoreflect.ValueOfList(value)
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints"))
		}
		panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName()))
	}
}

// NewField returns a new value that is assignable to the field
// for the given descriptor. For scalars, this returns the default value.
// For lists, maps, and messages, this returns a new, empty, mutable value.
func (x *fastReflection_TestRepeatedUints) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	switch fd.FullName() {
	case "testpb.TestRepeatedUints.nums":
		list := []uint64{}
		return protoreflect.ValueOfList(&_TestRepeatedUints_1_list{list: &list})
	default:
		if fd.IsExtension() {
			panic(fmt.Errorf("proto3 declared messages do not support extensions: testpb.TestRepeatedUints"))
		}
		panic(fmt.Errorf("message testpb.TestRepeatedUints does not contain field %s", fd.FullName()))
	}
}

// WhichOneof reports which field within the oneof is populated,
// returning nil if none are populated.
// It panics if the oneof descriptor does not belong to this message.
func (x *fastReflection_TestRepeatedUints) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	switch d.FullName() {
	default:
		panic(fmt.Errorf("%s is not a oneof field in testpb.TestRepeatedUints", d.FullName()))
	}
	panic("unreachable")
}

// GetUnknown retrieves the entire list of unknown fields.
// The caller may only mutate the contents of the RawFields
// if the mutated bytes are stored back into the message with SetUnknown.
func (x *fastReflection_TestRepeatedUints) GetUnknown() protoreflect.RawFields {
	return x.unknownFields
}

// SetUnknown stores an entire list of unknown fields.
// The raw fields must be syntactically valid according to the wire format.
// An implementation may panic if this is not the case.
// Once stored, the caller must not mutate the content of the RawFields.
// An empty RawFields may be passed to clear the fields.
//
// SetUnknown is a mutating operation and unsafe for concurrent use.
func (x *fastReflection_TestRepeatedUints) SetUnknown(fields protoreflect.RawFields) {
	x.unknownFields = fields
}

// IsValid reports whether the message is valid.
//
// An invalid message is an empty, read-only value.
//
// An invalid message often corresponds to a nil pointer of the concrete
// message type, but the details are implementation dependent.
// Validity is not part of the protobuf data model, and may not
// be preserved in marshaling or other operations.
func (x *fastReflection_TestRepeatedUints) IsValid() bool {
	return x != nil
}

// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations.
// This method may return nil.
//
// The returned methods type is identical to
// "google.golang.org/protobuf/runtime/protoiface".Methods.
// Consult the protoiface package documentation for details.
func (x *fastReflection_TestRepeatedUints) ProtoMethods() *protoiface.Methods {
	size := func(input protoiface.SizeInput) protoiface.SizeOutput {
		x := input.Message.Interface().(*TestRepeatedUints)
		if x == nil {
			return protoiface.SizeOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Size:              0,
			}
		}
		options := runtime.SizeInputToOptions(input)
		_ = options
		var n int
		var l int
		_ = l
		if len(x.Nums) > 0 {
			l = 0
			for _, e := range x.Nums {
				l += runtime.Sov(uint64(e))
			}
			n += 1 + runtime.Sov(uint64(l)) + l
		}
		if x.unknownFields != nil {
			n += len(x.unknownFields)
		}
		return protoiface.SizeOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Size:              n,
		}
	}

	marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
		x := input.Message.Interface().(*TestRepeatedUints)
		if x == nil {
			return protoiface.MarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Buf:               input.Buf,
			}, nil
		}
		options := runtime.MarshalInputToOptions(input)
		_ = options
		size := options.Size(x)
		dAtA := make([]byte, size)
		i := len(dAtA)
		_ = i
		var l int
		_ = l
		if x.unknownFields != nil {
			i -= len(x.unknownFields)
			copy(dAtA[i:], x.unknownFields)
		}
		if len(x.Nums) > 0 {
			var pksize2 int
			for _, num := range x.Nums {
				pksize2 += runtime.Sov(uint64(num))
			}
			i -= pksize2
			j1 := i
			for _, num := range x.Nums {
				for num >= 1<<7 {
					dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
					num >>= 7
					j1++
				}
				dAtA[j1] = uint8(num)
				j1++
			}
			i = runtime.EncodeVarint(dAtA, i, uint64(pksize2))
			i--
			dAtA[i] = 0xa
		}
		if input.Buf != nil {
			input.Buf = append(input.Buf, dAtA...)
		} else {
			input.Buf = dAtA
		}
		return protoiface.MarshalOutput{
			NoUnkeyedLiterals: input.NoUnkeyedLiterals,
			Buf:               input.Buf,
		}, nil
	}
	unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
		x := input.Message.Interface().(*TestRepeatedUints)
		if x == nil {
			return protoiface.UnmarshalOutput{
				NoUnkeyedLiterals: input.NoUnkeyedLiterals,
				Flags:             input.Flags,
			}, nil
		}
		options := runtime.UnmarshalInputToOptions(input)
		_ = options
		dAtA := input.Buf
		l := len(dAtA)
		iNdEx := 0
		for iNdEx < l {
			preIndex := iNdEx
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
				}
				if iNdEx >= l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				wire |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			fieldNum := int32(wire >> 3)
			wireType := int(wire & 0x7)
			if wireType == 4 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestRepeatedUints: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: TestRepeatedUints: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 1:
				if wireType == 0 {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
						}
						if iNdEx >= l {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					x.Nums = append(x.Nums, v)
				} else if wireType == 2 {
					var packedLen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
						}
						if iNdEx >= l {
							return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						packedLen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if packedLen < 0 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
					}
					postIndex := iNdEx + packedLen
					if postIndex < 0 {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
					}
					if postIndex > l {
						return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
					}
					var elementCount int
					var count int
					for _, integer := range dAtA[iNdEx:postIndex] {
						if integer < 128 {
							count++
						}
					}
					elementCount = count
					if elementCount != 0 && len(x.Nums) == 0 {
						x.Nums = make([]uint64, 0, elementCount)
					}
					for iNdEx < postIndex {
						var v uint64
						for shift := uint(0); ; shift += 7 {
							if shift >= 64 {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow
							}
							if iNdEx >= l {
								return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
							}
							b := dAtA[iNdEx]
							iNdEx++
							v |= uint64(b&0x7F) << shift
							if b < 0x80 {
								break
							}
						}
						x.Nums = append(x.Nums, v)
					}
				} else {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nums", wireType)
				}
			default:
				iNdEx = preIndex
				skippy, err := runtime.Skip(dAtA[iNdEx:])
				if err != nil {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err
				}
				if (skippy < 0) || (iNdEx+skippy) < 0 {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength
				}
				if (iNdEx + skippy) > l {
					return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
				}
				if !options.DiscardUnknown {
					x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
				}
				iNdEx += skippy
			}
		}

		if iNdEx > l {
			return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF
		}
		return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil
	}
	return &protoiface.Methods{
		NoUnkeyedLiterals: struct{}{},
		Flags:             protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown,
		Size:              size,
		Marshal:           marshal,
		Unmarshal:         unmarshal,
		Merge:             nil,
		CheckInitialized:  nil,
	}
}

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.27.0
// 	protoc        (unknown)
// source: testpb/unknonwnproto.proto

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type Customer2_City int32

const (
	Customer2_Laos       Customer2_City = 0
	Customer2_LosAngeles Customer2_City = 1
	Customer2_PaloAlto   Customer2_City = 2
	Customer2_Moscow     Customer2_City = 3
	Customer2_Nairobi    Customer2_City = 4
)

// Enum value maps for Customer2_City.
var (
	Customer2_City_name = map[int32]string{
		0: "Laos",
		1: "LosAngeles",
		2: "PaloAlto",
		3: "Moscow",
		4: "Nairobi",
	}
	Customer2_City_value = map[string]int32{
		"Laos":       0,
		"LosAngeles": 1,
		"PaloAlto":   2,
		"Moscow":     3,
		"Nairobi":    4,
	}
)

func (x Customer2_City) Enum() *Customer2_City {
	p := new(Customer2_City)
	*p = x
	return p
}

func (x Customer2_City) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Customer2_City) Descriptor() protoreflect.EnumDescriptor {
	return file_testpb_unknonwnproto_proto_enumTypes[0].Descriptor()
}

func (Customer2_City) Type() protoreflect.EnumType {
	return &file_testpb_unknonwnproto_proto_enumTypes[0]
}

func (x Customer2_City) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Customer2_City.Descriptor instead.
func (Customer2_City) EnumDescriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{1, 0}
}

type Customer1 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id              int32   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name            string  `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	SubscriptionFee float32 `protobuf:"fixed32,3,opt,name=subscription_fee,json=subscriptionFee,proto3" json:"subscription_fee,omitempty"`
	Payment         string  `protobuf:"bytes,7,opt,name=payment,proto3" json:"payment,omitempty"`
}

func (x *Customer1) Reset() {
	*x = Customer1{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Customer1) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Customer1) ProtoMessage() {}

// Deprecated: Use Customer1.ProtoReflect.Descriptor instead.
func (*Customer1) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{0}
}

func (x *Customer1) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Customer1) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Customer1) GetSubscriptionFee() float32 {
	if x != nil {
		return x.SubscriptionFee
	}
	return 0
}

func (x *Customer1) GetPayment() string {
	if x != nil {
		return x.Payment
	}
	return ""
}

type Customer2 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id            int32          `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Industry      int32          `protobuf:"varint,2,opt,name=industry,proto3" json:"industry,omitempty"`
	Name          string         `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Fewer         float32        `protobuf:"fixed32,4,opt,name=fewer,proto3" json:"fewer,omitempty"`
	Reserved      int64          `protobuf:"varint,1047,opt,name=reserved,proto3" json:"reserved,omitempty"`
	City          Customer2_City `protobuf:"varint,6,opt,name=city,proto3,enum=testpb.Customer2_City" json:"city,omitempty"`
	Miscellaneous *anypb.Any     `protobuf:"bytes,10,opt,name=miscellaneous,proto3" json:"miscellaneous,omitempty"`
}

func (x *Customer2) Reset() {
	*x = Customer2{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Customer2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Customer2) ProtoMessage() {}

// Deprecated: Use Customer2.ProtoReflect.Descriptor instead.
func (*Customer2) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{1}
}

func (x *Customer2) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Customer2) GetIndustry() int32 {
	if x != nil {
		return x.Industry
	}
	return 0
}

func (x *Customer2) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Customer2) GetFewer() float32 {
	if x != nil {
		return x.Fewer
	}
	return 0
}

func (x *Customer2) GetReserved() int64 {
	if x != nil {
		return x.Reserved
	}
	return 0
}

func (x *Customer2) GetCity() Customer2_City {
	if x != nil {
		return x.City
	}
	return Customer2_Laos
}

func (x *Customer2) GetMiscellaneous() *anypb.Any {
	if x != nil {
		return x.Miscellaneous
	}
	return nil
}

type Nested4A struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id   int32  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (x *Nested4A) Reset() {
	*x = Nested4A{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested4A) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested4A) ProtoMessage() {}

// Deprecated: Use Nested4A.ProtoReflect.Descriptor instead.
func (*Nested4A) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{2}
}

func (x *Nested4A) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested4A) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

type Nested3A struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id    int32               `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name  string              `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	A4    []*Nested4A         `protobuf:"bytes,4,rep,name=a4,proto3" json:"a4,omitempty"`
	Index map[int64]*Nested4A `protobuf:"bytes,5,rep,name=index,proto3" json:"index,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (x *Nested3A) Reset() {
	*x = Nested3A{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested3A) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested3A) ProtoMessage() {}

// Deprecated: Use Nested3A.ProtoReflect.Descriptor instead.
func (*Nested3A) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{3}
}

func (x *Nested3A) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested3A) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Nested3A) GetA4() []*Nested4A {
	if x != nil {
		return x.A4
	}
	return nil
}

func (x *Nested3A) GetIndex() map[int64]*Nested4A {
	if x != nil {
		return x.Index
	}
	return nil
}

type Nested2A struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id     int32     `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name   string    `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Nested *Nested3A `protobuf:"bytes,3,opt,name=nested,proto3" json:"nested,omitempty"`
}

func (x *Nested2A) Reset() {
	*x = Nested2A{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested2A) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested2A) ProtoMessage() {}

// Deprecated: Use Nested2A.ProtoReflect.Descriptor instead.
func (*Nested2A) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{4}
}

func (x *Nested2A) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested2A) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Nested2A) GetNested() *Nested3A {
	if x != nil {
		return x.Nested
	}
	return nil
}

type Nested1A struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id     int32     `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Nested *Nested2A `protobuf:"bytes,2,opt,name=nested,proto3" json:"nested,omitempty"`
}

func (x *Nested1A) Reset() {
	*x = Nested1A{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested1A) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested1A) ProtoMessage() {}

// Deprecated: Use Nested1A.ProtoReflect.Descriptor instead.
func (*Nested1A) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{5}
}

func (x *Nested1A) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested1A) GetNested() *Nested2A {
	if x != nil {
		return x.Nested
	}
	return nil
}

type Nested4B struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id   int32  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Age  int32  `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
}

func (x *Nested4B) Reset() {
	*x = Nested4B{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested4B) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested4B) ProtoMessage() {}

// Deprecated: Use Nested4B.ProtoReflect.Descriptor instead.
func (*Nested4B) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{6}
}

func (x *Nested4B) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested4B) GetAge() int32 {
	if x != nil {
		return x.Age
	}
	return 0
}

func (x *Nested4B) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

type Nested3B struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id   int32       `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Age  int32       `protobuf:"varint,2,opt,name=age,proto3" json:"age,omitempty"`
	Name string      `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	B4   []*Nested4B `protobuf:"bytes,4,rep,name=b4,proto3" json:"b4,omitempty"`
}

func (x *Nested3B) Reset() {
	*x = Nested3B{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested3B) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested3B) ProtoMessage() {}

// Deprecated: Use Nested3B.ProtoReflect.Descriptor instead.
func (*Nested3B) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{7}
}

func (x *Nested3B) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested3B) GetAge() int32 {
	if x != nil {
		return x.Age
	}
	return 0
}

func (x *Nested3B) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Nested3B) GetB4() []*Nested4B {
	if x != nil {
		return x.B4
	}
	return nil
}

type Nested2B struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id     int32     `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Fee    float64   `protobuf:"fixed64,2,opt,name=fee,proto3" json:"fee,omitempty"`
	Nested *Nested3B `protobuf:"bytes,3,opt,name=nested,proto3" json:"nested,omitempty"`
	Route  string    `protobuf:"bytes,4,opt,name=route,proto3" json:"route,omitempty"`
}

func (x *Nested2B) Reset() {
	*x = Nested2B{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[8]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested2B) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested2B) ProtoMessage() {}

// Deprecated: Use Nested2B.ProtoReflect.Descriptor instead.
func (*Nested2B) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{8}
}

func (x *Nested2B) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested2B) GetFee() float64 {
	if x != nil {
		return x.Fee
	}
	return 0
}

func (x *Nested2B) GetNested() *Nested3B {
	if x != nil {
		return x.Nested
	}
	return nil
}

func (x *Nested2B) GetRoute() string {
	if x != nil {
		return x.Route
	}
	return ""
}

type Nested1B struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id     int32     `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Nested *Nested2B `protobuf:"bytes,2,opt,name=nested,proto3" json:"nested,omitempty"`
	Age    int32     `protobuf:"varint,3,opt,name=age,proto3" json:"age,omitempty"`
}

func (x *Nested1B) Reset() {
	*x = Nested1B{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[9]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Nested1B) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Nested1B) ProtoMessage() {}

// Deprecated: Use Nested1B.ProtoReflect.Descriptor instead.
func (*Nested1B) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{9}
}

func (x *Nested1B) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Nested1B) GetNested() *Nested2B {
	if x != nil {
		return x.Nested
	}
	return nil
}

func (x *Nested1B) GetAge() int32 {
	if x != nil {
		return x.Age
	}
	return 0
}

type Customer3 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id          int32   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name        string  `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Sf          float32 `protobuf:"fixed32,3,opt,name=sf,proto3" json:"sf,omitempty"`
	Surcharge   float32 `protobuf:"fixed32,4,opt,name=surcharge,proto3" json:"surcharge,omitempty"`
	Destination string  `protobuf:"bytes,5,opt,name=destination,proto3" json:"destination,omitempty"`
	// Types that are assignable to Payment:
	//
	//	*Customer3_CreditCardNo
	//	*Customer3_ChequeNo
	Payment  isCustomer3_Payment `protobuf_oneof:"payment"`
	Original *Customer1          `protobuf:"bytes,9,opt,name=original,proto3" json:"original,omitempty"`
}

func (x *Customer3) Reset() {
	*x = Customer3{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[10]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *Customer3) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Customer3) ProtoMessage() {}

// Deprecated: Use Customer3.ProtoReflect.Descriptor instead.
func (*Customer3) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{10}
}

func (x *Customer3) GetId() int32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Customer3) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Customer3) GetSf() float32 {
	if x != nil {
		return x.Sf
	}
	return 0
}

func (x *Customer3) GetSurcharge() float32 {
	if x != nil {
		return x.Surcharge
	}
	return 0
}

func (x *Customer3) GetDestination() string {
	if x != nil {
		return x.Destination
	}
	return ""
}

func (x *Customer3) GetPayment() isCustomer3_Payment {
	if x != nil {
		return x.Payment
	}
	return nil
}

func (x *Customer3) GetCreditCardNo() string {
	if x, ok := x.GetPayment().(*Customer3_CreditCardNo); ok {
		return x.CreditCardNo
	}
	return ""
}

func (x *Customer3) GetChequeNo() string {
	if x, ok := x.GetPayment().(*Customer3_ChequeNo); ok {
		return x.ChequeNo
	}
	return ""
}

func (x *Customer3) GetOriginal() *Customer1 {
	if x != nil {
		return x.Original
	}
	return nil
}

type isCustomer3_Payment interface {
	isCustomer3_Payment()
}

type Customer3_CreditCardNo struct {
	CreditCardNo string `protobuf:"bytes,7,opt,name=credit_card_no,json=creditCardNo,proto3,oneof"`
}

type Customer3_ChequeNo struct {
	ChequeNo string `protobuf:"bytes,8,opt,name=cheque_no,json=chequeNo,proto3,oneof"`
}

func (*Customer3_CreditCardNo) isCustomer3_Payment() {}

func (*Customer3_ChequeNo) isCustomer3_Payment() {}

type TestVersion1 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64           `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion1   `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	B *TestVersion1   `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false] generates invalid recursive structs;
	C []*TestVersion1 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"`
	D []*TestVersion1 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"`
	// Types that are assignable to Sum:
	//
	//	*TestVersion1_E
	//	*TestVersion1_F
	Sum isTestVersion1_Sum `protobuf_oneof:"sum"`
	G   *anypb.Any         `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1    `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"];
	// google.protobuf.Timestamp i = 10;
	// google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true];
	K *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"`
}

func (x *TestVersion1) Reset() {
	*x = TestVersion1{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[11]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion1) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion1) ProtoMessage() {}

// Deprecated: Use TestVersion1.ProtoReflect.Descriptor instead.
func (*TestVersion1) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{11}
}

func (x *TestVersion1) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersion1) GetA() *TestVersion1 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersion1) GetB() *TestVersion1 {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *TestVersion1) GetC() []*TestVersion1 {
	if x != nil {
		return x.C
	}
	return nil
}

func (x *TestVersion1) GetD() []*TestVersion1 {
	if x != nil {
		return x.D
	}
	return nil
}

func (x *TestVersion1) GetSum() isTestVersion1_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersion1) GetE() int32 {
	if x, ok := x.GetSum().(*TestVersion1_E); ok {
		return x.E
	}
	return 0
}

func (x *TestVersion1) GetF() *TestVersion1 {
	if x, ok := x.GetSum().(*TestVersion1_F); ok {
		return x.F
	}
	return nil
}

func (x *TestVersion1) GetG() *anypb.Any {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersion1) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

func (x *TestVersion1) GetK() *Customer1 {
	if x != nil {
		return x.K
	}
	return nil
}

type isTestVersion1_Sum interface {
	isTestVersion1_Sum()
}

type TestVersion1_E struct {
	E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"`
}

type TestVersion1_F struct {
	F *TestVersion1 `protobuf:"bytes,7,opt,name=f,proto3,oneof"`
}

func (*TestVersion1_E) isTestVersion1_Sum() {}

func (*TestVersion1_F) isTestVersion1_Sum() {}

type TestVersion2 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64           `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion2   `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	B *TestVersion2   `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false];
	C []*TestVersion2 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"`
	D []*TestVersion2 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false];
	// Types that are assignable to Sum:
	//
	//	*TestVersion2_E
	//	*TestVersion2_F
	Sum isTestVersion2_Sum `protobuf_oneof:"sum"`
	G   *anypb.Any         `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1    `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"];
	// google.protobuf.Timestamp i = 10;
	// google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true];
	K         *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"`
	NewField_ uint64     `protobuf:"varint,25,opt,name=new_field,json=newField,proto3" json:"new_field,omitempty"`
}

func (x *TestVersion2) Reset() {
	*x = TestVersion2{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[12]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion2) ProtoMessage() {}

// Deprecated: Use TestVersion2.ProtoReflect.Descriptor instead.
func (*TestVersion2) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{12}
}

func (x *TestVersion2) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersion2) GetA() *TestVersion2 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersion2) GetB() *TestVersion2 {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *TestVersion2) GetC() []*TestVersion2 {
	if x != nil {
		return x.C
	}
	return nil
}

func (x *TestVersion2) GetD() []*TestVersion2 {
	if x != nil {
		return x.D
	}
	return nil
}

func (x *TestVersion2) GetSum() isTestVersion2_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersion2) GetE() int32 {
	if x, ok := x.GetSum().(*TestVersion2_E); ok {
		return x.E
	}
	return 0
}

func (x *TestVersion2) GetF() *TestVersion2 {
	if x, ok := x.GetSum().(*TestVersion2_F); ok {
		return x.F
	}
	return nil
}

func (x *TestVersion2) GetG() *anypb.Any {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersion2) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

func (x *TestVersion2) GetK() *Customer1 {
	if x != nil {
		return x.K
	}
	return nil
}

func (x *TestVersion2) GetNewField_() uint64 {
	if x != nil {
		return x.NewField_
	}
	return 0
}

type isTestVersion2_Sum interface {
	isTestVersion2_Sum()
}

type TestVersion2_E struct {
	E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"`
}

type TestVersion2_F struct {
	F *TestVersion2 `protobuf:"bytes,7,opt,name=f,proto3,oneof"`
}

func (*TestVersion2_E) isTestVersion2_Sum() {}

func (*TestVersion2_F) isTestVersion2_Sum() {}

type TestVersion3 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64           `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion3   `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	B *TestVersion3   `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false];
	C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"`
	D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false];
	// Types that are assignable to Sum:
	//
	//	*TestVersion3_E
	//	*TestVersion3_F
	Sum isTestVersion3_Sum `protobuf_oneof:"sum"`
	G   *anypb.Any         `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1    `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"];
	// google.protobuf.Timestamp i = 10;
	// google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true];
	K                *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"`
	NonCriticalField string     `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"`
}

func (x *TestVersion3) Reset() {
	*x = TestVersion3{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[13]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion3) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion3) ProtoMessage() {}

// Deprecated: Use TestVersion3.ProtoReflect.Descriptor instead.
func (*TestVersion3) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{13}
}

func (x *TestVersion3) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersion3) GetA() *TestVersion3 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersion3) GetB() *TestVersion3 {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *TestVersion3) GetC() []*TestVersion3 {
	if x != nil {
		return x.C
	}
	return nil
}

func (x *TestVersion3) GetD() []*TestVersion3 {
	if x != nil {
		return x.D
	}
	return nil
}

func (x *TestVersion3) GetSum() isTestVersion3_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersion3) GetE() int32 {
	if x, ok := x.GetSum().(*TestVersion3_E); ok {
		return x.E
	}
	return 0
}

func (x *TestVersion3) GetF() *TestVersion3 {
	if x, ok := x.GetSum().(*TestVersion3_F); ok {
		return x.F
	}
	return nil
}

func (x *TestVersion3) GetG() *anypb.Any {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersion3) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

func (x *TestVersion3) GetK() *Customer1 {
	if x != nil {
		return x.K
	}
	return nil
}

func (x *TestVersion3) GetNonCriticalField() string {
	if x != nil {
		return x.NonCriticalField
	}
	return ""
}

type isTestVersion3_Sum interface {
	isTestVersion3_Sum()
}

type TestVersion3_E struct {
	E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"`
}

type TestVersion3_F struct {
	F *TestVersion3 `protobuf:"bytes,7,opt,name=f,proto3,oneof"`
}

func (*TestVersion3_E) isTestVersion3_Sum() {}

func (*TestVersion3_F) isTestVersion3_Sum() {}

type TestVersion3LoneOneOfValue struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64           `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion3   `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	B *TestVersion3   `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false];
	C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"`
	D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false];
	// Types that are assignable to Sum:
	//
	//	*TestVersion3LoneOneOfValue_E
	Sum isTestVersion3LoneOneOfValue_Sum `protobuf_oneof:"sum"`
	G   *anypb.Any                       `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1                  `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"];
	// google.protobuf.Timestamp i = 10;
	// google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true];
	K                *Customer1 `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"`
	NonCriticalField string     `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"`
}

func (x *TestVersion3LoneOneOfValue) Reset() {
	*x = TestVersion3LoneOneOfValue{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[14]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion3LoneOneOfValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion3LoneOneOfValue) ProtoMessage() {}

// Deprecated: Use TestVersion3LoneOneOfValue.ProtoReflect.Descriptor instead.
func (*TestVersion3LoneOneOfValue) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{14}
}

func (x *TestVersion3LoneOneOfValue) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersion3LoneOneOfValue) GetA() *TestVersion3 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetB() *TestVersion3 {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetC() []*TestVersion3 {
	if x != nil {
		return x.C
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetD() []*TestVersion3 {
	if x != nil {
		return x.D
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetSum() isTestVersion3LoneOneOfValue_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetE() int32 {
	if x, ok := x.GetSum().(*TestVersion3LoneOneOfValue_E); ok {
		return x.E
	}
	return 0
}

func (x *TestVersion3LoneOneOfValue) GetG() *anypb.Any {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetK() *Customer1 {
	if x != nil {
		return x.K
	}
	return nil
}

func (x *TestVersion3LoneOneOfValue) GetNonCriticalField() string {
	if x != nil {
		return x.NonCriticalField
	}
	return ""
}

type isTestVersion3LoneOneOfValue_Sum interface {
	isTestVersion3LoneOneOfValue_Sum()
}

type TestVersion3LoneOneOfValue_E struct {
	E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"`
}

func (*TestVersion3LoneOneOfValue_E) isTestVersion3LoneOneOfValue_Sum() {}

type TestVersion3LoneNesting struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64           `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion3   `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	B *TestVersion3   `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false];
	C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"`
	D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false];
	// Types that are assignable to Sum:
	//
	//	*TestVersion3LoneNesting_F
	Sum isTestVersion3LoneNesting_Sum `protobuf_oneof:"sum"`
	G   *anypb.Any                    `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1               `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"];
	// google.protobuf.Timestamp i = 10;
	// google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true];
	K                *Customer1                      `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"`
	NonCriticalField string                          `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"`
	Inner1           *TestVersion3LoneNesting_Inner1 `protobuf:"bytes,14,opt,name=inner1,proto3" json:"inner1,omitempty"`
	Inner2           *TestVersion3LoneNesting_Inner2 `protobuf:"bytes,15,opt,name=inner2,proto3" json:"inner2,omitempty"`
}

func (x *TestVersion3LoneNesting) Reset() {
	*x = TestVersion3LoneNesting{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[15]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion3LoneNesting) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion3LoneNesting) ProtoMessage() {}

// Deprecated: Use TestVersion3LoneNesting.ProtoReflect.Descriptor instead.
func (*TestVersion3LoneNesting) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{15}
}

func (x *TestVersion3LoneNesting) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersion3LoneNesting) GetA() *TestVersion3 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetB() *TestVersion3 {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetC() []*TestVersion3 {
	if x != nil {
		return x.C
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetD() []*TestVersion3 {
	if x != nil {
		return x.D
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetSum() isTestVersion3LoneNesting_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetF() *TestVersion3LoneNesting {
	if x, ok := x.GetSum().(*TestVersion3LoneNesting_F); ok {
		return x.F
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetG() *anypb.Any {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetK() *Customer1 {
	if x != nil {
		return x.K
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetNonCriticalField() string {
	if x != nil {
		return x.NonCriticalField
	}
	return ""
}

func (x *TestVersion3LoneNesting) GetInner1() *TestVersion3LoneNesting_Inner1 {
	if x != nil {
		return x.Inner1
	}
	return nil
}

func (x *TestVersion3LoneNesting) GetInner2() *TestVersion3LoneNesting_Inner2 {
	if x != nil {
		return x.Inner2
	}
	return nil
}

type isTestVersion3LoneNesting_Sum interface {
	isTestVersion3LoneNesting_Sum()
}

type TestVersion3LoneNesting_F struct {
	F *TestVersion3LoneNesting `protobuf:"bytes,7,opt,name=f,proto3,oneof"`
}

func (*TestVersion3LoneNesting_F) isTestVersion3LoneNesting_Sum() {}

type TestVersion4LoneNesting struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64           `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion3   `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	B *TestVersion3   `protobuf:"bytes,3,opt,name=b,proto3" json:"b,omitempty"` // [(gogoproto.nullable) = false];
	C []*TestVersion3 `protobuf:"bytes,4,rep,name=c,proto3" json:"c,omitempty"`
	D []*TestVersion3 `protobuf:"bytes,5,rep,name=d,proto3" json:"d,omitempty"` // [(gogoproto.nullable) = false];
	// Types that are assignable to Sum:
	//
	//	*TestVersion4LoneNesting_F
	Sum isTestVersion4LoneNesting_Sum `protobuf_oneof:"sum"`
	G   *anypb.Any                    `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1               `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` //[(gogoproto.castrepeated) = "TestVersion1"];
	// google.protobuf.Timestamp i = 10;
	// google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true];
	K                *Customer1                      `protobuf:"bytes,12,opt,name=k,proto3" json:"k,omitempty"`
	NonCriticalField string                          `protobuf:"bytes,1031,opt,name=non_critical_field,json=nonCriticalField,proto3" json:"non_critical_field,omitempty"`
	Inner1           *TestVersion4LoneNesting_Inner1 `protobuf:"bytes,14,opt,name=inner1,proto3" json:"inner1,omitempty"`
	Inner2           *TestVersion4LoneNesting_Inner2 `protobuf:"bytes,15,opt,name=inner2,proto3" json:"inner2,omitempty"`
}

func (x *TestVersion4LoneNesting) Reset() {
	*x = TestVersion4LoneNesting{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[16]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion4LoneNesting) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion4LoneNesting) ProtoMessage() {}

// Deprecated: Use TestVersion4LoneNesting.ProtoReflect.Descriptor instead.
func (*TestVersion4LoneNesting) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{16}
}

func (x *TestVersion4LoneNesting) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersion4LoneNesting) GetA() *TestVersion3 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetB() *TestVersion3 {
	if x != nil {
		return x.B
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetC() []*TestVersion3 {
	if x != nil {
		return x.C
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetD() []*TestVersion3 {
	if x != nil {
		return x.D
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetSum() isTestVersion4LoneNesting_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetF() *TestVersion3LoneNesting {
	if x, ok := x.GetSum().(*TestVersion4LoneNesting_F); ok {
		return x.F
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetG() *anypb.Any {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetK() *Customer1 {
	if x != nil {
		return x.K
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetNonCriticalField() string {
	if x != nil {
		return x.NonCriticalField
	}
	return ""
}

func (x *TestVersion4LoneNesting) GetInner1() *TestVersion4LoneNesting_Inner1 {
	if x != nil {
		return x.Inner1
	}
	return nil
}

func (x *TestVersion4LoneNesting) GetInner2() *TestVersion4LoneNesting_Inner2 {
	if x != nil {
		return x.Inner2
	}
	return nil
}

type isTestVersion4LoneNesting_Sum interface {
	isTestVersion4LoneNesting_Sum()
}

type TestVersion4LoneNesting_F struct {
	F *TestVersion3LoneNesting `protobuf:"bytes,7,opt,name=f,proto3,oneof"`
}

func (*TestVersion4LoneNesting_F) isTestVersion4LoneNesting_Sum() {}

type TestVersionFD1 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64         `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion1 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	// Types that are assignable to Sum:
	//
	//	*TestVersionFD1_E
	//	*TestVersionFD1_F
	Sum isTestVersionFD1_Sum `protobuf_oneof:"sum"`
	G   *anypb.Any           `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1      `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"];
}

func (x *TestVersionFD1) Reset() {
	*x = TestVersionFD1{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[17]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersionFD1) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersionFD1) ProtoMessage() {}

// Deprecated: Use TestVersionFD1.ProtoReflect.Descriptor instead.
func (*TestVersionFD1) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{17}
}

func (x *TestVersionFD1) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersionFD1) GetA() *TestVersion1 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersionFD1) GetSum() isTestVersionFD1_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersionFD1) GetE() int32 {
	if x, ok := x.GetSum().(*TestVersionFD1_E); ok {
		return x.E
	}
	return 0
}

func (x *TestVersionFD1) GetF() *TestVersion1 {
	if x, ok := x.GetSum().(*TestVersionFD1_F); ok {
		return x.F
	}
	return nil
}

func (x *TestVersionFD1) GetG() *anypb.Any {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersionFD1) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

type isTestVersionFD1_Sum interface {
	isTestVersionFD1_Sum()
}

type TestVersionFD1_E struct {
	E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"`
}

type TestVersionFD1_F struct {
	F *TestVersion1 `protobuf:"bytes,7,opt,name=f,proto3,oneof"`
}

func (*TestVersionFD1_E) isTestVersionFD1_Sum() {}

func (*TestVersionFD1_F) isTestVersionFD1_Sum() {}

type TestVersionFD1WithExtraAny struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	X int64         `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"`
	A *TestVersion1 `protobuf:"bytes,2,opt,name=a,proto3" json:"a,omitempty"`
	// Types that are assignable to Sum:
	//
	//	*TestVersionFD1WithExtraAny_E
	//	*TestVersionFD1WithExtraAny_F
	Sum isTestVersionFD1WithExtraAny_Sum `protobuf_oneof:"sum"`
	G   *AnyWithExtra                    `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
	H   []*TestVersion1                  `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"` // [(gogoproto.castrepeated) = "TestVersion1"];
}

func (x *TestVersionFD1WithExtraAny) Reset() {
	*x = TestVersionFD1WithExtraAny{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[18]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersionFD1WithExtraAny) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersionFD1WithExtraAny) ProtoMessage() {}

// Deprecated: Use TestVersionFD1WithExtraAny.ProtoReflect.Descriptor instead.
func (*TestVersionFD1WithExtraAny) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{18}
}

func (x *TestVersionFD1WithExtraAny) GetX() int64 {
	if x != nil {
		return x.X
	}
	return 0
}

func (x *TestVersionFD1WithExtraAny) GetA() *TestVersion1 {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *TestVersionFD1WithExtraAny) GetSum() isTestVersionFD1WithExtraAny_Sum {
	if x != nil {
		return x.Sum
	}
	return nil
}

func (x *TestVersionFD1WithExtraAny) GetE() int32 {
	if x, ok := x.GetSum().(*TestVersionFD1WithExtraAny_E); ok {
		return x.E
	}
	return 0
}

func (x *TestVersionFD1WithExtraAny) GetF() *TestVersion1 {
	if x, ok := x.GetSum().(*TestVersionFD1WithExtraAny_F); ok {
		return x.F
	}
	return nil
}

func (x *TestVersionFD1WithExtraAny) GetG() *AnyWithExtra {
	if x != nil {
		return x.G
	}
	return nil
}

func (x *TestVersionFD1WithExtraAny) GetH() []*TestVersion1 {
	if x != nil {
		return x.H
	}
	return nil
}

type isTestVersionFD1WithExtraAny_Sum interface {
	isTestVersionFD1WithExtraAny_Sum()
}

type TestVersionFD1WithExtraAny_E struct {
	E int32 `protobuf:"varint,6,opt,name=e,proto3,oneof"`
}

type TestVersionFD1WithExtraAny_F struct {
	F *TestVersion1 `protobuf:"bytes,7,opt,name=f,proto3,oneof"`
}

func (*TestVersionFD1WithExtraAny_E) isTestVersionFD1WithExtraAny_Sum() {}

func (*TestVersionFD1WithExtraAny_F) isTestVersionFD1WithExtraAny_Sum() {}

type AnyWithExtra struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	A *anypb.Any `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	B int64      `protobuf:"varint,3,opt,name=b,proto3" json:"b,omitempty"`
	C int64      `protobuf:"varint,4,opt,name=c,proto3" json:"c,omitempty"`
}

func (x *AnyWithExtra) Reset() {
	*x = AnyWithExtra{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[19]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *AnyWithExtra) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AnyWithExtra) ProtoMessage() {}

// Deprecated: Use AnyWithExtra.ProtoReflect.Descriptor instead.
func (*AnyWithExtra) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{19}
}

func (x *AnyWithExtra) GetA() *anypb.Any {
	if x != nil {
		return x.A
	}
	return nil
}

func (x *AnyWithExtra) GetB() int64 {
	if x != nil {
		return x.B
	}
	return 0
}

func (x *AnyWithExtra) GetC() int64 {
	if x != nil {
		return x.C
	}
	return 0
}

type TestUpdatedTxRaw struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	BodyBytes     []byte   `protobuf:"bytes,1,opt,name=body_bytes,json=bodyBytes,proto3" json:"body_bytes,omitempty"`
	AuthInfoBytes []byte   `protobuf:"bytes,2,opt,name=auth_info_bytes,json=authInfoBytes,proto3" json:"auth_info_bytes,omitempty"`
	Signatures    [][]byte `protobuf:"bytes,3,rep,name=signatures,proto3" json:"signatures,omitempty"`
	NewField_5    []byte   `protobuf:"bytes,5,opt,name=new_field_5,json=newField5,proto3" json:"new_field_5,omitempty"`
	NewField_1024 []byte   `protobuf:"bytes,1024,opt,name=new_field_1024,json=newField1024,proto3" json:"new_field_1024,omitempty"`
}

func (x *TestUpdatedTxRaw) Reset() {
	*x = TestUpdatedTxRaw{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[20]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestUpdatedTxRaw) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestUpdatedTxRaw) ProtoMessage() {}

// Deprecated: Use TestUpdatedTxRaw.ProtoReflect.Descriptor instead.
func (*TestUpdatedTxRaw) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{20}
}

func (x *TestUpdatedTxRaw) GetBodyBytes() []byte {
	if x != nil {
		return x.BodyBytes
	}
	return nil
}

func (x *TestUpdatedTxRaw) GetAuthInfoBytes() []byte {
	if x != nil {
		return x.AuthInfoBytes
	}
	return nil
}

func (x *TestUpdatedTxRaw) GetSignatures() [][]byte {
	if x != nil {
		return x.Signatures
	}
	return nil
}

func (x *TestUpdatedTxRaw) GetNewField_5() []byte {
	if x != nil {
		return x.NewField_5
	}
	return nil
}

func (x *TestUpdatedTxRaw) GetNewField_1024() []byte {
	if x != nil {
		return x.NewField_1024
	}
	return nil
}

type TestUpdatedTxBody struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Messages                     []*anypb.Any `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages,omitempty"`
	Memo                         string       `protobuf:"bytes,2,opt,name=memo,proto3" json:"memo,omitempty"`
	TimeoutHeight                int64        `protobuf:"varint,3,opt,name=timeout_height,json=timeoutHeight,proto3" json:"timeout_height,omitempty"`
	SomeNewField                 uint64       `protobuf:"varint,5,opt,name=some_new_field,json=someNewField,proto3" json:"some_new_field,omitempty"`
	SomeNewFieldNonCriticalField string       `protobuf:"bytes,1050,opt,name=some_new_field_non_critical_field,json=someNewFieldNonCriticalField,proto3" json:"some_new_field_non_critical_field,omitempty"`
	ExtensionOptions             []*anypb.Any `protobuf:"bytes,1023,rep,name=extension_options,json=extensionOptions,proto3" json:"extension_options,omitempty"`
	NonCriticalExtensionOptions  []*anypb.Any `protobuf:"bytes,2047,rep,name=non_critical_extension_options,json=nonCriticalExtensionOptions,proto3" json:"non_critical_extension_options,omitempty"`
}

func (x *TestUpdatedTxBody) Reset() {
	*x = TestUpdatedTxBody{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[21]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestUpdatedTxBody) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestUpdatedTxBody) ProtoMessage() {}

// Deprecated: Use TestUpdatedTxBody.ProtoReflect.Descriptor instead.
func (*TestUpdatedTxBody) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{21}
}

func (x *TestUpdatedTxBody) GetMessages() []*anypb.Any {
	if x != nil {
		return x.Messages
	}
	return nil
}

func (x *TestUpdatedTxBody) GetMemo() string {
	if x != nil {
		return x.Memo
	}
	return ""
}

func (x *TestUpdatedTxBody) GetTimeoutHeight() int64 {
	if x != nil {
		return x.TimeoutHeight
	}
	return 0
}

func (x *TestUpdatedTxBody) GetSomeNewField() uint64 {
	if x != nil {
		return x.SomeNewField
	}
	return 0
}

func (x *TestUpdatedTxBody) GetSomeNewFieldNonCriticalField() string {
	if x != nil {
		return x.SomeNewFieldNonCriticalField
	}
	return ""
}

func (x *TestUpdatedTxBody) GetExtensionOptions() []*anypb.Any {
	if x != nil {
		return x.ExtensionOptions
	}
	return nil
}

func (x *TestUpdatedTxBody) GetNonCriticalExtensionOptions() []*anypb.Any {
	if x != nil {
		return x.NonCriticalExtensionOptions
	}
	return nil
}

type TestUpdatedAuthInfo struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	SignerInfos   []*v1beta1.SignerInfo `protobuf:"bytes,1,rep,name=signer_infos,json=signerInfos,proto3" json:"signer_infos,omitempty"`
	Fee           *v1beta1.Fee          `protobuf:"bytes,2,opt,name=fee,proto3" json:"fee,omitempty"`
	NewField_3    []byte                `protobuf:"bytes,3,opt,name=new_field_3,json=newField3,proto3" json:"new_field_3,omitempty"`
	NewField_1024 []byte                `protobuf:"bytes,1024,opt,name=new_field_1024,json=newField1024,proto3" json:"new_field_1024,omitempty"`
}

func (x *TestUpdatedAuthInfo) Reset() {
	*x = TestUpdatedAuthInfo{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[22]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestUpdatedAuthInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestUpdatedAuthInfo) ProtoMessage() {}

// Deprecated: Use TestUpdatedAuthInfo.ProtoReflect.Descriptor instead.
func (*TestUpdatedAuthInfo) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{22}
}

func (x *TestUpdatedAuthInfo) GetSignerInfos() []*v1beta1.SignerInfo {
	if x != nil {
		return x.SignerInfos
	}
	return nil
}

func (x *TestUpdatedAuthInfo) GetFee() *v1beta1.Fee {
	if x != nil {
		return x.Fee
	}
	return nil
}

func (x *TestUpdatedAuthInfo) GetNewField_3() []byte {
	if x != nil {
		return x.NewField_3
	}
	return nil
}

func (x *TestUpdatedAuthInfo) GetNewField_1024() []byte {
	if x != nil {
		return x.NewField_1024
	}
	return nil
}

type TestRepeatedUints struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Nums []uint64 `protobuf:"varint,1,rep,packed,name=nums,proto3" json:"nums,omitempty"`
}

func (x *TestRepeatedUints) Reset() {
	*x = TestRepeatedUints{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[23]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestRepeatedUints) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestRepeatedUints) ProtoMessage() {}

// Deprecated: Use TestRepeatedUints.ProtoReflect.Descriptor instead.
func (*TestRepeatedUints) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{23}
}

func (x *TestRepeatedUints) GetNums() []uint64 {
	if x != nil {
		return x.Nums
	}
	return nil
}

type TestVersion3LoneNesting_Inner1 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id    int64                                      `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name  string                                     `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Inner *TestVersion3LoneNesting_Inner1_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"`
}

func (x *TestVersion3LoneNesting_Inner1) Reset() {
	*x = TestVersion3LoneNesting_Inner1{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[25]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion3LoneNesting_Inner1) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion3LoneNesting_Inner1) ProtoMessage() {}

// Deprecated: Use TestVersion3LoneNesting_Inner1.ProtoReflect.Descriptor instead.
func (*TestVersion3LoneNesting_Inner1) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{15, 0}
}

func (x *TestVersion3LoneNesting_Inner1) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *TestVersion3LoneNesting_Inner1) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *TestVersion3LoneNesting_Inner1) GetInner() *TestVersion3LoneNesting_Inner1_InnerInner {
	if x != nil {
		return x.Inner
	}
	return nil
}

type TestVersion3LoneNesting_Inner2 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id      string                                     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Country string                                     `protobuf:"bytes,2,opt,name=country,proto3" json:"country,omitempty"`
	Inner   *TestVersion3LoneNesting_Inner2_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"`
}

func (x *TestVersion3LoneNesting_Inner2) Reset() {
	*x = TestVersion3LoneNesting_Inner2{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[26]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion3LoneNesting_Inner2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion3LoneNesting_Inner2) ProtoMessage() {}

// Deprecated: Use TestVersion3LoneNesting_Inner2.ProtoReflect.Descriptor instead.
func (*TestVersion3LoneNesting_Inner2) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{15, 1}
}

func (x *TestVersion3LoneNesting_Inner2) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *TestVersion3LoneNesting_Inner2) GetCountry() string {
	if x != nil {
		return x.Country
	}
	return ""
}

func (x *TestVersion3LoneNesting_Inner2) GetInner() *TestVersion3LoneNesting_Inner2_InnerInner {
	if x != nil {
		return x.Inner
	}
	return nil
}

type TestVersion3LoneNesting_Inner1_InnerInner struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"`
}

func (x *TestVersion3LoneNesting_Inner1_InnerInner) Reset() {
	*x = TestVersion3LoneNesting_Inner1_InnerInner{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[27]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion3LoneNesting_Inner1_InnerInner) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion3LoneNesting_Inner1_InnerInner) ProtoMessage() {}

// Deprecated: Use TestVersion3LoneNesting_Inner1_InnerInner.ProtoReflect.Descriptor instead.
func (*TestVersion3LoneNesting_Inner1_InnerInner) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{15, 0, 0}
}

func (x *TestVersion3LoneNesting_Inner1_InnerInner) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *TestVersion3LoneNesting_Inner1_InnerInner) GetCity() string {
	if x != nil {
		return x.City
	}
	return ""
}

type TestVersion3LoneNesting_Inner2_InnerInner struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"`
}

func (x *TestVersion3LoneNesting_Inner2_InnerInner) Reset() {
	*x = TestVersion3LoneNesting_Inner2_InnerInner{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[28]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion3LoneNesting_Inner2_InnerInner) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion3LoneNesting_Inner2_InnerInner) ProtoMessage() {}

// Deprecated: Use TestVersion3LoneNesting_Inner2_InnerInner.ProtoReflect.Descriptor instead.
func (*TestVersion3LoneNesting_Inner2_InnerInner) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{15, 1, 0}
}

func (x *TestVersion3LoneNesting_Inner2_InnerInner) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *TestVersion3LoneNesting_Inner2_InnerInner) GetCity() string {
	if x != nil {
		return x.City
	}
	return ""
}

type TestVersion4LoneNesting_Inner1 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id    int64                                      `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name  string                                     `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Inner *TestVersion4LoneNesting_Inner1_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"`
}

func (x *TestVersion4LoneNesting_Inner1) Reset() {
	*x = TestVersion4LoneNesting_Inner1{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[29]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion4LoneNesting_Inner1) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion4LoneNesting_Inner1) ProtoMessage() {}

// Deprecated: Use TestVersion4LoneNesting_Inner1.ProtoReflect.Descriptor instead.
func (*TestVersion4LoneNesting_Inner1) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{16, 0}
}

func (x *TestVersion4LoneNesting_Inner1) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *TestVersion4LoneNesting_Inner1) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *TestVersion4LoneNesting_Inner1) GetInner() *TestVersion4LoneNesting_Inner1_InnerInner {
	if x != nil {
		return x.Inner
	}
	return nil
}

type TestVersion4LoneNesting_Inner2 struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id      string                                     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Country string                                     `protobuf:"bytes,2,opt,name=country,proto3" json:"country,omitempty"`
	Inner   *TestVersion4LoneNesting_Inner2_InnerInner `protobuf:"bytes,3,opt,name=inner,proto3" json:"inner,omitempty"`
}

func (x *TestVersion4LoneNesting_Inner2) Reset() {
	*x = TestVersion4LoneNesting_Inner2{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[30]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion4LoneNesting_Inner2) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion4LoneNesting_Inner2) ProtoMessage() {}

// Deprecated: Use TestVersion4LoneNesting_Inner2.ProtoReflect.Descriptor instead.
func (*TestVersion4LoneNesting_Inner2) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{16, 1}
}

func (x *TestVersion4LoneNesting_Inner2) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *TestVersion4LoneNesting_Inner2) GetCountry() string {
	if x != nil {
		return x.Country
	}
	return ""
}

func (x *TestVersion4LoneNesting_Inner2) GetInner() *TestVersion4LoneNesting_Inner2_InnerInner {
	if x != nil {
		return x.Inner
	}
	return nil
}

type TestVersion4LoneNesting_Inner1_InnerInner struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id   int64  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	City string `protobuf:"bytes,2,opt,name=city,proto3" json:"city,omitempty"`
}

func (x *TestVersion4LoneNesting_Inner1_InnerInner) Reset() {
	*x = TestVersion4LoneNesting_Inner1_InnerInner{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[31]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion4LoneNesting_Inner1_InnerInner) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion4LoneNesting_Inner1_InnerInner) ProtoMessage() {}

// Deprecated: Use TestVersion4LoneNesting_Inner1_InnerInner.ProtoReflect.Descriptor instead.
func (*TestVersion4LoneNesting_Inner1_InnerInner) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{16, 0, 0}
}

func (x *TestVersion4LoneNesting_Inner1_InnerInner) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *TestVersion4LoneNesting_Inner1_InnerInner) GetCity() string {
	if x != nil {
		return x.City
	}
	return ""
}

type TestVersion4LoneNesting_Inner2_InnerInner struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Id    string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Value int64  `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (x *TestVersion4LoneNesting_Inner2_InnerInner) Reset() {
	*x = TestVersion4LoneNesting_Inner2_InnerInner{}
	if protoimpl.UnsafeEnabled {
		mi := &file_testpb_unknonwnproto_proto_msgTypes[32]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *TestVersion4LoneNesting_Inner2_InnerInner) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestVersion4LoneNesting_Inner2_InnerInner) ProtoMessage() {}

// Deprecated: Use TestVersion4LoneNesting_Inner2_InnerInner.ProtoReflect.Descriptor instead.
func (*TestVersion4LoneNesting_Inner2_InnerInner) Descriptor() ([]byte, []int) {
	return file_testpb_unknonwnproto_proto_rawDescGZIP(), []int{16, 1, 0}
}

func (x *TestVersion4LoneNesting_Inner2_InnerInner) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *TestVersion4LoneNesting_Inner2_InnerInner) GetValue() int64 {
	if x != nil {
		return x.Value
	}
	return 0
}

var File_testpb_unknonwnproto_proto protoreflect.FileDescriptor

var file_testpb_unknonwnproto_proto_rawDesc = []byte{
	0x0a, 0x1a, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2f, 0x75, 0x6e, 0x6b, 0x6e, 0x6f, 0x6e, 0x77,
	0x6e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x1a, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
	0x67, 0x6f, 0x67, 0x6f, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67,
	0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x74, 0x78,
	0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x22, 0x74, 0x0a, 0x09, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x12, 0x0e,
	0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12,
	0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
	0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69,
	0x6f, 0x6e, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0f, 0x73, 0x75,
	0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x65, 0x65, 0x12, 0x18, 0x0a,
	0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
	0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0xaf, 0x02, 0x0a, 0x09, 0x43, 0x75, 0x73, 0x74,
	0x6f, 0x6d, 0x65, 0x72, 0x32, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72,
	0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x69, 0x6e, 0x64, 0x75, 0x73, 0x74, 0x72,
	0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x65, 0x77, 0x65, 0x72, 0x18, 0x04,
	0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x66, 0x65, 0x77, 0x65, 0x72, 0x12, 0x1b, 0x0a, 0x08, 0x72,
	0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x18, 0x97, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08,
	0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x12, 0x2a, 0x0a, 0x04, 0x63, 0x69, 0x74, 0x79,
	0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x16, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e,
	0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x32, 0x2e, 0x43, 0x69, 0x74, 0x79, 0x52, 0x04,
	0x63, 0x69, 0x74, 0x79, 0x12, 0x3a, 0x0a, 0x0d, 0x6d, 0x69, 0x73, 0x63, 0x65, 0x6c, 0x6c, 0x61,
	0x6e, 0x65, 0x6f, 0x75, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f,
	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e,
	0x79, 0x52, 0x0d, 0x6d, 0x69, 0x73, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x6e, 0x65, 0x6f, 0x75, 0x73,
	0x22, 0x47, 0x0a, 0x04, 0x43, 0x69, 0x74, 0x79, 0x12, 0x08, 0x0a, 0x04, 0x4c, 0x61, 0x6f, 0x73,
	0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4c, 0x6f, 0x73, 0x41, 0x6e, 0x67, 0x65, 0x6c, 0x65, 0x73,
	0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x50, 0x61, 0x6c, 0x6f, 0x41, 0x6c, 0x74, 0x6f, 0x10, 0x02,
	0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x6f, 0x73, 0x63, 0x6f, 0x77, 0x10, 0x03, 0x12, 0x0b, 0x0a, 0x07,
	0x4e, 0x61, 0x69, 0x72, 0x6f, 0x62, 0x69, 0x10, 0x04, 0x22, 0x2e, 0x0a, 0x08, 0x4e, 0x65, 0x73,
	0x74, 0x65, 0x64, 0x34, 0x41, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0xcf, 0x01, 0x0a, 0x08, 0x4e, 0x65,
	0x73, 0x74, 0x65, 0x64, 0x33, 0x41, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
	0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x02, 0x61, 0x34,
	0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e,
	0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x34, 0x41, 0x52, 0x02, 0x61, 0x34, 0x12, 0x31, 0x0a, 0x05,
	0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x33, 0x41, 0x2e, 0x49, 0x6e,
	0x64, 0x65, 0x78, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x1a,
	0x4a, 0x0a, 0x0a, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a,
	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
	0x26, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10,
	0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x34, 0x41,
	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x58, 0x0a, 0x08, 0x4e,
	0x65, 0x73, 0x74, 0x65, 0x64, 0x32, 0x41, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x28, 0x0a, 0x06, 0x6e,
	0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x33, 0x41, 0x52, 0x06, 0x6e,
	0x65, 0x73, 0x74, 0x65, 0x64, 0x22, 0x44, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x31,
	0x41, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69,
	0x64, 0x12, 0x28, 0x0a, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65,
	0x64, 0x32, 0x41, 0x52, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x22, 0x40, 0x0a, 0x08, 0x4e,
	0x65, 0x73, 0x74, 0x65, 0x64, 0x34, 0x42, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d,
	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x62, 0x0a,
	0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x33, 0x42, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65,
	0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e,
	0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
	0x20, 0x0a, 0x02, 0x62, 0x34, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x34, 0x42, 0x52, 0x02, 0x62,
	0x34, 0x22, 0x6c, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x32, 0x42, 0x12, 0x0e, 0x0a,
	0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x10, 0x0a,
	0x03, 0x66, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x03, 0x66, 0x65, 0x65, 0x12,
	0x28, 0x0a, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
	0x10, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x33,
	0x42, 0x52, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x6f, 0x75,
	0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x22,
	0x56, 0x0a, 0x08, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x31, 0x42, 0x12, 0x0e, 0x0a, 0x02, 0x69,
	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x28, 0x0a, 0x06, 0x6e,
	0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x32, 0x42, 0x52, 0x06, 0x6e,
	0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01,
	0x28, 0x05, 0x52, 0x03, 0x61, 0x67, 0x65, 0x22, 0x80, 0x02, 0x0a, 0x09, 0x43, 0x75, 0x73, 0x74,
	0x6f, 0x6d, 0x65, 0x72, 0x33, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x73, 0x66, 0x18,
	0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x02, 0x73, 0x66, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x75, 0x72,
	0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x73, 0x75,
	0x72, 0x63, 0x68, 0x61, 0x72, 0x67, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x74, 0x69,
	0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65,
	0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x26, 0x0a, 0x0e, 0x63, 0x72, 0x65,
	0x64, 0x69, 0x74, 0x5f, 0x63, 0x61, 0x72, 0x64, 0x5f, 0x6e, 0x6f, 0x18, 0x07, 0x20, 0x01, 0x28,
	0x09, 0x48, 0x00, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x64, 0x69, 0x74, 0x43, 0x61, 0x72, 0x64, 0x4e,
	0x6f, 0x12, 0x1d, 0x0a, 0x09, 0x63, 0x68, 0x65, 0x71, 0x75, 0x65, 0x5f, 0x6e, 0x6f, 0x18, 0x08,
	0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x08, 0x63, 0x68, 0x65, 0x71, 0x75, 0x65, 0x4e, 0x6f,
	0x12, 0x2d, 0x0a, 0x08, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x18, 0x09, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74,
	0x6f, 0x6d, 0x65, 0x72, 0x31, 0x52, 0x08, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x42,
	0x09, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0xde, 0x02, 0x0a, 0x0c, 0x54,
	0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x12, 0x0c, 0x0a, 0x01, 0x78,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65,
	0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a,
	0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70,
	0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01,
	0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74,
	0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
	0x6e, 0x31, 0x52, 0x01, 0x63, 0x12, 0x28, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b,
	0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65,
	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x42, 0x04, 0xc8, 0xde, 0x1f, 0x00, 0x52, 0x01, 0x64, 0x12,
	0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65, 0x12,
	0x24, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73,
	0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31,
	0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
	0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09,
	0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65,
	0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a,
	0x01, 0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70,
	0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f,
	0x01, 0x52, 0x01, 0x6b, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xf5, 0x02, 0x0a, 0x0c,
	0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x12, 0x0c, 0x0a, 0x01,
	0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54,
	0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x52, 0x01, 0x61, 0x12, 0x22,
	0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74,
	0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x52,
	0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e,
	0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69,
	0x6f, 0x6e, 0x32, 0x52, 0x01, 0x63, 0x12, 0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28,
	0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56,
	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x52, 0x01, 0x64, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18,
	0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, 0x18,
	0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54,
	0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x48, 0x00, 0x52, 0x01, 0x66,
	0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f,
	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e,
	0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32,
	0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72,
	0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, 0x20,
	0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73,
	0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, 0x12,
	0x1b, 0x0a, 0x09, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x19, 0x20, 0x01,
	0x28, 0x04, 0x52, 0x08, 0x6e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x05, 0x0a, 0x03,
	0x73, 0x75, 0x6d, 0x22, 0x87, 0x03, 0x0a, 0x0c, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73,
	0x69, 0x6f, 0x6e, 0x33, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52,
	0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e,
	0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69,
	0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56,
	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18,
	0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54,
	0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x63, 0x12, 0x22,
	0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74,
	0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52,
	0x01, 0x64, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52,
	0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e,
	0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69,
	0x6f, 0x6e, 0x33, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20,
	0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01,
	0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62,
	0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68,
	0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04,
	0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6e, 0x5f, 0x63,
	0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x87, 0x08,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61,
	0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xef, 0x02,
	0x0a, 0x1a, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f,
	0x6e, 0x65, 0x4f, 0x6e, 0x65, 0x4f, 0x66, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x0c, 0x0a, 0x01,
	0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54,
	0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, 0x12, 0x22,
	0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74,
	0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52,
	0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e,
	0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69,
	0x6f, 0x6e, 0x33, 0x52, 0x01, 0x63, 0x12, 0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28,
	0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56,
	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x64, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18,
	0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18,
	0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22,
	0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74,
	0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52,
	0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e,
	0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31,
	0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6e,
	0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18,
	0x87, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69,
	0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22,
	0xe7, 0x06, 0x0a, 0x17, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33,
	0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x78,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65,
	0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a,
	0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70,
	0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01,
	0x62, 0x12, 0x22, 0x0a, 0x01, 0x63, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74,
	0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
	0x6e, 0x33, 0x52, 0x01, 0x63, 0x12, 0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b,
	0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65,
	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x64, 0x12, 0x2f, 0x0a, 0x01, 0x66, 0x18, 0x07,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65,
	0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65,
	0x73, 0x74, 0x69, 0x6e, 0x67, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18,
	0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22,
	0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74,
	0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52,
	0x01, 0x68, 0x12, 0x25, 0x0a, 0x01, 0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e,
	0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31,
	0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x6b, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6e,
	0x5f, 0x63, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18,
	0x87, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x6e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69,
	0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x3e, 0x0a, 0x06, 0x69, 0x6e, 0x6e, 0x65,
	0x72, 0x31, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70,
	0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f,
	0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31,
	0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x12, 0x3e, 0x0a, 0x06, 0x69, 0x6e, 0x6e, 0x65,
	0x72, 0x32, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70,
	0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f,
	0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32,
	0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x1a, 0xa7, 0x01, 0x0a, 0x06, 0x49, 0x6e, 0x6e,
	0x65, 0x72, 0x31, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52,
	0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
	0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72,
	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e,
	0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65,
	0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x2e, 0x49,
	0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72,
	0x1a, 0x30, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x12, 0x0e,
	0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12,
	0x0a, 0x04, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x69,
	0x74, 0x79, 0x1a, 0xad, 0x01, 0x0a, 0x06, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x12, 0x0e, 0x0a,
	0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x18, 0x0a,
	0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
	0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72,
	0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e,
	0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65,
	0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x2e, 0x49,
	0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72,
	0x1a, 0x30, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x12, 0x0e,
	0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12,
	0x0a, 0x04, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x69,
	0x74, 0x79, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xe9, 0x06, 0x0a, 0x17, 0x54, 0x65,
	0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65,
	0x73, 0x74, 0x69, 0x6e, 0x67, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03,
	0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14,
	0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73,
	0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x61, 0x12, 0x22, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74,
	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x62, 0x12, 0x22, 0x0a, 0x01, 0x63,
	0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e,
	0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33, 0x52, 0x01, 0x63, 0x12,
	0x22, 0x0a, 0x01, 0x64, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73,
	0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x33,
	0x52, 0x01, 0x64, 0x12, 0x2f, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f,
	0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73,
	0x69, 0x6f, 0x6e, 0x33, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, 0x48,
	0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32,
	0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
	0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20,
	0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73,
	0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x12, 0x25, 0x0a, 0x01,
	0x6b, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62,
	0x2e, 0x43, 0x75, 0x73, 0x74, 0x6f, 0x6d, 0x65, 0x72, 0x31, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01,
	0x52, 0x01, 0x6b, 0x12, 0x2d, 0x0a, 0x12, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69, 0x74, 0x69,
	0x63, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x87, 0x08, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x10, 0x6e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x69, 0x65,
	0x6c, 0x64, 0x12, 0x3e, 0x0a, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x18, 0x0e, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74,
	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74,
	0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65,
	0x72, 0x31, 0x12, 0x3e, 0x0a, 0x06, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x18, 0x0f, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x26, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74,
	0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74,
	0x69, 0x6e, 0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x52, 0x06, 0x69, 0x6e, 0x6e, 0x65,
	0x72, 0x32, 0x1a, 0xa7, 0x01, 0x0a, 0x06, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x12, 0x0e, 0x0a,
	0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a,
	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d,
	0x65, 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65,
	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e,
	0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x31, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e,
	0x6e, 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x1a, 0x30, 0x0a, 0x0a, 0x49, 0x6e,
	0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
	0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x63, 0x69, 0x74, 0x79,
	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x63, 0x69, 0x74, 0x79, 0x1a, 0xaf, 0x01, 0x0a,
	0x06, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74,
	0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x72,
	0x79, 0x12, 0x47, 0x0a, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x31, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65,
	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x34, 0x4c, 0x6f, 0x6e, 0x65, 0x4e, 0x65, 0x73, 0x74, 0x69, 0x6e,
	0x67, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x32, 0x2e, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x49, 0x6e,
	0x6e, 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x1a, 0x32, 0x0a, 0x0a, 0x49, 0x6e,
	0x6e, 0x65, 0x72, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x05,
	0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0xc7, 0x01, 0x0a, 0x0e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65,
	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x46, 0x44, 0x31, 0x12, 0x0c, 0x0a, 0x01, 0x78, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56,
	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x61, 0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18,
	0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65, 0x12, 0x24, 0x0a, 0x01, 0x66, 0x18,
	0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54,
	0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x48, 0x00, 0x52, 0x01, 0x66,
	0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f,
	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e,
	0x79, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32,
	0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72,
	0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x42, 0x05, 0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22,
	0xd3, 0x01, 0x0a, 0x1a, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x46,
	0x44, 0x31, 0x57, 0x69, 0x74, 0x68, 0x45, 0x78, 0x74, 0x72, 0x61, 0x41, 0x6e, 0x79, 0x12, 0x0c,
	0x0a, 0x01, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x78, 0x12, 0x22, 0x0a, 0x01,
	0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62,
	0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x61,
	0x12, 0x0e, 0x0a, 0x01, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x01, 0x65,
	0x12, 0x24, 0x0a, 0x01, 0x66, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
	0x31, 0x48, 0x00, 0x52, 0x01, 0x66, 0x12, 0x22, 0x0a, 0x01, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x41, 0x6e, 0x79, 0x57, 0x69,
	0x74, 0x68, 0x45, 0x78, 0x74, 0x72, 0x61, 0x52, 0x01, 0x67, 0x12, 0x22, 0x0a, 0x01, 0x68, 0x18,
	0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0x2e, 0x54,
	0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x31, 0x52, 0x01, 0x68, 0x42, 0x05,
	0x0a, 0x03, 0x73, 0x75, 0x6d, 0x22, 0x54, 0x0a, 0x0c, 0x41, 0x6e, 0x79, 0x57, 0x69, 0x74, 0x68,
	0x45, 0x78, 0x74, 0x72, 0x61, 0x12, 0x28, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
	0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x42, 0x04, 0xd0, 0xde, 0x1f, 0x01, 0x52, 0x01, 0x61, 0x12,
	0x0c, 0x0a, 0x01, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x62, 0x12, 0x0c, 0x0a,
	0x01, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x01, 0x63, 0x22, 0xc0, 0x01, 0x0a, 0x10,
	0x54, 0x65, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x54, 0x78, 0x52, 0x61, 0x77,
	0x12, 0x1d, 0x0a, 0x0a, 0x62, 0x6f, 0x64, 0x79, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01,
	0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, 0x6f, 0x64, 0x79, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12,
	0x26, 0x0a, 0x0f, 0x61, 0x75, 0x74, 0x68, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x62, 0x79, 0x74,
	0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x61, 0x75, 0x74, 0x68, 0x49, 0x6e,
	0x66, 0x6f, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x69, 0x67, 0x6e, 0x61,
	0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0a, 0x73, 0x69, 0x67,
	0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x1e, 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x66,
	0x69, 0x65, 0x6c, 0x64, 0x5f, 0x35, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x6e, 0x65,
	0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x12, 0x25, 0x0a, 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x66,
	0x69, 0x65, 0x6c, 0x64, 0x5f, 0x31, 0x30, 0x32, 0x34, 0x18, 0x80, 0x08, 0x20, 0x01, 0x28, 0x0c,
	0x52, 0x0c, 0x6e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x22, 0x90,
	0x03, 0x0a, 0x11, 0x54, 0x65, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x54, 0x78,
	0x42, 0x6f, 0x64, 0x79, 0x12, 0x30, 0x0a, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73,
	0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x08, 0x6d, 0x65,
	0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x65, 0x6d, 0x6f, 0x18, 0x02,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6d, 0x65, 0x6d, 0x6f, 0x12, 0x25, 0x0a, 0x0e, 0x74, 0x69,
	0x6d, 0x65, 0x6f, 0x75, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01,
	0x28, 0x03, 0x52, 0x0d, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68,
	0x74, 0x12, 0x24, 0x0a, 0x0e, 0x73, 0x6f, 0x6d, 0x65, 0x5f, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69,
	0x65, 0x6c, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0c, 0x73, 0x6f, 0x6d, 0x65, 0x4e,
	0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x48, 0x0a, 0x21, 0x73, 0x6f, 0x6d, 0x65, 0x5f,
	0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72,
	0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x9a, 0x08, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x1c, 0x73, 0x6f, 0x6d, 0x65, 0x4e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c,
	0x64, 0x4e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x46, 0x69, 0x65, 0x6c,
	0x64, 0x12, 0x42, 0x0a, 0x11, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x6f,
	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xff, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e,
	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
	0x41, 0x6e, 0x79, 0x52, 0x10, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4f, 0x70,
	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5a, 0x0a, 0x1e, 0x6e, 0x6f, 0x6e, 0x5f, 0x63, 0x72, 0x69,
	0x74, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
	0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xff, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14,
	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
	0x2e, 0x41, 0x6e, 0x79, 0x52, 0x1b, 0x6e, 0x6f, 0x6e, 0x43, 0x72, 0x69, 0x74, 0x69, 0x63, 0x61,
	0x6c, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
	0x73, 0x22, 0xc8, 0x01, 0x0a, 0x13, 0x54, 0x65, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
	0x64, 0x41, 0x75, 0x74, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x40, 0x0a, 0x0c, 0x73, 0x69, 0x67,
	0x6e, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
	0x1d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x74, 0x78, 0x2e, 0x76, 0x31, 0x62, 0x65,
	0x74, 0x61, 0x31, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0b,
	0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x12, 0x28, 0x0a, 0x03, 0x66,
	0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f,
	0x73, 0x2e, 0x74, 0x78, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x46, 0x65, 0x65,
	0x52, 0x03, 0x66, 0x65, 0x65, 0x12, 0x1e, 0x0a, 0x0b, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65,
	0x6c, 0x64, 0x5f, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x6e, 0x65, 0x77, 0x46,
	0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x25, 0x0a, 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x66, 0x69, 0x65,
	0x6c, 0x64, 0x5f, 0x31, 0x30, 0x32, 0x34, 0x18, 0x80, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c,
	0x6e, 0x65, 0x77, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x30, 0x32, 0x34, 0x22, 0x27, 0x0a, 0x11,
	0x54, 0x65, 0x73, 0x74, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x65, 0x64, 0x55, 0x69, 0x6e, 0x74,
	0x73, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x75, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x04, 0x52,
	0x04, 0x6e, 0x75, 0x6d, 0x73, 0x42, 0x96, 0x01, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x2e, 0x74, 0x65,
	0x73, 0x74, 0x70, 0x62, 0x42, 0x12, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x6e, 0x77, 0x6e, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3c, 0x67, 0x69, 0x74, 0x68,
	0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x6f,
	0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x75, 0x74, 0x69,
	0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x75, 0x6c, 0x73, 0x61,
	0x72, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, 0x62, 0xa2, 0x02, 0x03, 0x54, 0x58, 0x58, 0xaa, 0x02,
	0x06, 0x54, 0x65, 0x73, 0x74, 0x70, 0x62, 0xca, 0x02, 0x06, 0x54, 0x65, 0x73, 0x74, 0x70, 0x62,
	0xe2, 0x02, 0x12, 0x54, 0x65, 0x73, 0x74, 0x70, 0x62, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74,
	0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x06, 0x54, 0x65, 0x73, 0x74, 0x70, 0x62, 0x62, 0x06,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_testpb_unknonwnproto_proto_rawDescOnce sync.Once
	file_testpb_unknonwnproto_proto_rawDescData = file_testpb_unknonwnproto_proto_rawDesc
)

func file_testpb_unknonwnproto_proto_rawDescGZIP() []byte {
	file_testpb_unknonwnproto_proto_rawDescOnce.Do(func() {
		file_testpb_unknonwnproto_proto_rawDescData = protoimpl.X.CompressGZIP(file_testpb_unknonwnproto_proto_rawDescData)
	})
	return file_testpb_unknonwnproto_proto_rawDescData
}

var file_testpb_unknonwnproto_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_testpb_unknonwnproto_proto_msgTypes = make([]protoimpl.MessageInfo, 33)
var file_testpb_unknonwnproto_proto_goTypes = []interface{}{
	(Customer2_City)(0),                               // 0: testpb.Customer2.City
	(*Customer1)(nil),                                 // 1: testpb.Customer1
	(*Customer2)(nil),                                 // 2: testpb.Customer2
	(*Nested4A)(nil),                                  // 3: testpb.Nested4A
	(*Nested3A)(nil),                                  // 4: testpb.Nested3A
	(*Nested2A)(nil),                                  // 5: testpb.Nested2A
	(*Nested1A)(nil),                                  // 6: testpb.Nested1A
	(*Nested4B)(nil),                                  // 7: testpb.Nested4B
	(*Nested3B)(nil),                                  // 8: testpb.Nested3B
	(*Nested2B)(nil),                                  // 9: testpb.Nested2B
	(*Nested1B)(nil),                                  // 10: testpb.Nested1B
	(*Customer3)(nil),                                 // 11: testpb.Customer3
	(*TestVersion1)(nil),                              // 12: testpb.TestVersion1
	(*TestVersion2)(nil),                              // 13: testpb.TestVersion2
	(*TestVersion3)(nil),                              // 14: testpb.TestVersion3
	(*TestVersion3LoneOneOfValue)(nil),                // 15: testpb.TestVersion3LoneOneOfValue
	(*TestVersion3LoneNesting)(nil),                   // 16: testpb.TestVersion3LoneNesting
	(*TestVersion4LoneNesting)(nil),                   // 17: testpb.TestVersion4LoneNesting
	(*TestVersionFD1)(nil),                            // 18: testpb.TestVersionFD1
	(*TestVersionFD1WithExtraAny)(nil),                // 19: testpb.TestVersionFD1WithExtraAny
	(*AnyWithExtra)(nil),                              // 20: testpb.AnyWithExtra
	(*TestUpdatedTxRaw)(nil),                          // 21: testpb.TestUpdatedTxRaw
	(*TestUpdatedTxBody)(nil),                         // 22: testpb.TestUpdatedTxBody
	(*TestUpdatedAuthInfo)(nil),                       // 23: testpb.TestUpdatedAuthInfo
	(*TestRepeatedUints)(nil),                         // 24: testpb.TestRepeatedUints
	nil,                                               // 25: testpb.Nested3A.IndexEntry
	(*TestVersion3LoneNesting_Inner1)(nil),            // 26: testpb.TestVersion3LoneNesting.Inner1
	(*TestVersion3LoneNesting_Inner2)(nil),            // 27: testpb.TestVersion3LoneNesting.Inner2
	(*TestVersion3LoneNesting_Inner1_InnerInner)(nil), // 28: testpb.TestVersion3LoneNesting.Inner1.InnerInner
	(*TestVersion3LoneNesting_Inner2_InnerInner)(nil), // 29: testpb.TestVersion3LoneNesting.Inner2.InnerInner
	(*TestVersion4LoneNesting_Inner1)(nil),            // 30: testpb.TestVersion4LoneNesting.Inner1
	(*TestVersion4LoneNesting_Inner2)(nil),            // 31: testpb.TestVersion4LoneNesting.Inner2
	(*TestVersion4LoneNesting_Inner1_InnerInner)(nil), // 32: testpb.TestVersion4LoneNesting.Inner1.InnerInner
	(*TestVersion4LoneNesting_Inner2_InnerInner)(nil), // 33: testpb.TestVersion4LoneNesting.Inner2.InnerInner
	(*anypb.Any)(nil),                                 // 34: google.protobuf.Any
	(*v1beta1.SignerInfo)(nil),                        // 35: cosmos.tx.v1beta1.SignerInfo
	(*v1beta1.Fee)(nil),                               // 36: cosmos.tx.v1beta1.Fee
}
var file_testpb_unknonwnproto_proto_depIdxs = []int32{
	0,  // 0: testpb.Customer2.city:type_name -> testpb.Customer2.City
	34, // 1: testpb.Customer2.miscellaneous:type_name -> google.protobuf.Any
	3,  // 2: testpb.Nested3A.a4:type_name -> testpb.Nested4A
	25, // 3: testpb.Nested3A.index:type_name -> testpb.Nested3A.IndexEntry
	4,  // 4: testpb.Nested2A.nested:type_name -> testpb.Nested3A
	5,  // 5: testpb.Nested1A.nested:type_name -> testpb.Nested2A
	7,  // 6: testpb.Nested3B.b4:type_name -> testpb.Nested4B
	8,  // 7: testpb.Nested2B.nested:type_name -> testpb.Nested3B
	9,  // 8: testpb.Nested1B.nested:type_name -> testpb.Nested2B
	1,  // 9: testpb.Customer3.original:type_name -> testpb.Customer1
	12, // 10: testpb.TestVersion1.a:type_name -> testpb.TestVersion1
	12, // 11: testpb.TestVersion1.b:type_name -> testpb.TestVersion1
	12, // 12: testpb.TestVersion1.c:type_name -> testpb.TestVersion1
	12, // 13: testpb.TestVersion1.d:type_name -> testpb.TestVersion1
	12, // 14: testpb.TestVersion1.f:type_name -> testpb.TestVersion1
	34, // 15: testpb.TestVersion1.g:type_name -> google.protobuf.Any
	12, // 16: testpb.TestVersion1.h:type_name -> testpb.TestVersion1
	1,  // 17: testpb.TestVersion1.k:type_name -> testpb.Customer1
	13, // 18: testpb.TestVersion2.a:type_name -> testpb.TestVersion2
	13, // 19: testpb.TestVersion2.b:type_name -> testpb.TestVersion2
	13, // 20: testpb.TestVersion2.c:type_name -> testpb.TestVersion2
	13, // 21: testpb.TestVersion2.d:type_name -> testpb.TestVersion2
	13, // 22: testpb.TestVersion2.f:type_name -> testpb.TestVersion2
	34, // 23: testpb.TestVersion2.g:type_name -> google.protobuf.Any
	12, // 24: testpb.TestVersion2.h:type_name -> testpb.TestVersion1
	1,  // 25: testpb.TestVersion2.k:type_name -> testpb.Customer1
	14, // 26: testpb.TestVersion3.a:type_name -> testpb.TestVersion3
	14, // 27: testpb.TestVersion3.b:type_name -> testpb.TestVersion3
	14, // 28: testpb.TestVersion3.c:type_name -> testpb.TestVersion3
	14, // 29: testpb.TestVersion3.d:type_name -> testpb.TestVersion3
	14, // 30: testpb.TestVersion3.f:type_name -> testpb.TestVersion3
	34, // 31: testpb.TestVersion3.g:type_name -> google.protobuf.Any
	12, // 32: testpb.TestVersion3.h:type_name -> testpb.TestVersion1
	1,  // 33: testpb.TestVersion3.k:type_name -> testpb.Customer1
	14, // 34: testpb.TestVersion3LoneOneOfValue.a:type_name -> testpb.TestVersion3
	14, // 35: testpb.TestVersion3LoneOneOfValue.b:type_name -> testpb.TestVersion3
	14, // 36: testpb.TestVersion3LoneOneOfValue.c:type_name -> testpb.TestVersion3
	14, // 37: testpb.TestVersion3LoneOneOfValue.d:type_name -> testpb.TestVersion3
	34, // 38: testpb.TestVersion3LoneOneOfValue.g:type_name -> google.protobuf.Any
	12, // 39: testpb.TestVersion3LoneOneOfValue.h:type_name -> testpb.TestVersion1
	1,  // 40: testpb.TestVersion3LoneOneOfValue.k:type_name -> testpb.Customer1
	14, // 41: testpb.TestVersion3LoneNesting.a:type_name -> testpb.TestVersion3
	14, // 42: testpb.TestVersion3LoneNesting.b:type_name -> testpb.TestVersion3
	14, // 43: testpb.TestVersion3LoneNesting.c:type_name -> testpb.TestVersion3
	14, // 44: testpb.TestVersion3LoneNesting.d:type_name -> testpb.TestVersion3
	16, // 45: testpb.TestVersion3LoneNesting.f:type_name -> testpb.TestVersion3LoneNesting
	34, // 46: testpb.TestVersion3LoneNesting.g:type_name -> google.protobuf.Any
	12, // 47: testpb.TestVersion3LoneNesting.h:type_name -> testpb.TestVersion1
	1,  // 48: testpb.TestVersion3LoneNesting.k:type_name -> testpb.Customer1
	26, // 49: testpb.TestVersion3LoneNesting.inner1:type_name -> testpb.TestVersion3LoneNesting.Inner1
	27, // 50: testpb.TestVersion3LoneNesting.inner2:type_name -> testpb.TestVersion3LoneNesting.Inner2
	14, // 51: testpb.TestVersion4LoneNesting.a:type_name -> testpb.TestVersion3
	14, // 52: testpb.TestVersion4LoneNesting.b:type_name -> testpb.TestVersion3
	14, // 53: testpb.TestVersion4LoneNesting.c:type_name -> testpb.TestVersion3
	14, // 54: testpb.TestVersion4LoneNesting.d:type_name -> testpb.TestVersion3
	16, // 55: testpb.TestVersion4LoneNesting.f:type_name -> testpb.TestVersion3LoneNesting
	34, // 56: testpb.TestVersion4LoneNesting.g:type_name -> google.protobuf.Any
	12, // 57: testpb.TestVersion4LoneNesting.h:type_name -> testpb.TestVersion1
	1,  // 58: testpb.TestVersion4LoneNesting.k:type_name -> testpb.Customer1
	30, // 59: testpb.TestVersion4LoneNesting.inner1:type_name -> testpb.TestVersion4LoneNesting.Inner1
	31, // 60: testpb.TestVersion4LoneNesting.inner2:type_name -> testpb.TestVersion4LoneNesting.Inner2
	12, // 61: testpb.TestVersionFD1.a:type_name -> testpb.TestVersion1
	12, // 62: testpb.TestVersionFD1.f:type_name -> testpb.TestVersion1
	34, // 63: testpb.TestVersionFD1.g:type_name -> google.protobuf.Any
	12, // 64: testpb.TestVersionFD1.h:type_name -> testpb.TestVersion1
	12, // 65: testpb.TestVersionFD1WithExtraAny.a:type_name -> testpb.TestVersion1
	12, // 66: testpb.TestVersionFD1WithExtraAny.f:type_name -> testpb.TestVersion1
	20, // 67: testpb.TestVersionFD1WithExtraAny.g:type_name -> testpb.AnyWithExtra
	12, // 68: testpb.TestVersionFD1WithExtraAny.h:type_name -> testpb.TestVersion1
	34, // 69: testpb.AnyWithExtra.a:type_name -> google.protobuf.Any
	34, // 70: testpb.TestUpdatedTxBody.messages:type_name -> google.protobuf.Any
	34, // 71: testpb.TestUpdatedTxBody.extension_options:type_name -> google.protobuf.Any
	34, // 72: testpb.TestUpdatedTxBody.non_critical_extension_options:type_name -> google.protobuf.Any
	35, // 73: testpb.TestUpdatedAuthInfo.signer_infos:type_name -> cosmos.tx.v1beta1.SignerInfo
	36, // 74: testpb.TestUpdatedAuthInfo.fee:type_name -> cosmos.tx.v1beta1.Fee
	3,  // 75: testpb.Nested3A.IndexEntry.value:type_name -> testpb.Nested4A
	28, // 76: testpb.TestVersion3LoneNesting.Inner1.inner:type_name -> testpb.TestVersion3LoneNesting.Inner1.InnerInner
	29, // 77: testpb.TestVersion3LoneNesting.Inner2.inner:type_name -> testpb.TestVersion3LoneNesting.Inner2.InnerInner
	32, // 78: testpb.TestVersion4LoneNesting.Inner1.inner:type_name -> testpb.TestVersion4LoneNesting.Inner1.InnerInner
	33, // 79: testpb.TestVersion4LoneNesting.Inner2.inner:type_name -> testpb.TestVersion4LoneNesting.Inner2.InnerInner
	80, // [80:80] is the sub-list for method output_type
	80, // [80:80] is the sub-list for method input_type
	80, // [80:80] is the sub-list for extension type_name
	80, // [80:80] is the sub-list for extension extendee
	0,  // [0:80] is the sub-list for field type_name
}

func init() { file_testpb_unknonwnproto_proto_init() }
func file_testpb_unknonwnproto_proto_init() {
	if File_testpb_unknonwnproto_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_testpb_unknonwnproto_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Customer1); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Customer2); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested4A); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested3A); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested2A); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested1A); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested4B); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested3B); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested2B); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Nested1B); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*Customer3); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion1); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion2); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion3); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion3LoneOneOfValue); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion3LoneNesting); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion4LoneNesting); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersionFD1); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersionFD1WithExtraAny); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*AnyWithExtra); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestUpdatedTxRaw); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestUpdatedTxBody); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestUpdatedAuthInfo); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestRepeatedUints); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion3LoneNesting_Inner1); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion3LoneNesting_Inner2); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion3LoneNesting_Inner1_InnerInner); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion3LoneNesting_Inner2_InnerInner); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion4LoneNesting_Inner1); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion4LoneNesting_Inner2); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion4LoneNesting_Inner1_InnerInner); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_testpb_unknonwnproto_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*TestVersion4LoneNesting_Inner2_InnerInner); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	file_testpb_unknonwnproto_proto_msgTypes[10].OneofWrappers = []interface{}{
		(*Customer3_CreditCardNo)(nil),
		(*Customer3_ChequeNo)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[11].OneofWrappers = []interface{}{
		(*TestVersion1_E)(nil),
		(*TestVersion1_F)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[12].OneofWrappers = []interface{}{
		(*TestVersion2_E)(nil),
		(*TestVersion2_F)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[13].OneofWrappers = []interface{}{
		(*TestVersion3_E)(nil),
		(*TestVersion3_F)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[14].OneofWrappers = []interface{}{
		(*TestVersion3LoneOneOfValue_E)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[15].OneofWrappers = []interface{}{
		(*TestVersion3LoneNesting_F)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[16].OneofWrappers = []interface{}{
		(*TestVersion4LoneNesting_F)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[17].OneofWrappers = []interface{}{
		(*TestVersionFD1_E)(nil),
		(*TestVersionFD1_F)(nil),
	}
	file_testpb_unknonwnproto_proto_msgTypes[18].OneofWrappers = []interface{}{
		(*TestVersionFD1WithExtraAny_E)(nil),
		(*TestVersionFD1WithExtraAny_F)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_testpb_unknonwnproto_proto_rawDesc,
			NumEnums:      1,
			NumMessages:   33,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_testpb_unknonwnproto_proto_goTypes,
		DependencyIndexes: file_testpb_unknonwnproto_proto_depIdxs,
		EnumInfos:         file_testpb_unknonwnproto_proto_enumTypes,
		MessageInfos:      file_testpb_unknonwnproto_proto_msgTypes,
	}.Build()
	File_testpb_unknonwnproto_proto = out.File
	file_testpb_unknonwnproto_proto_rawDesc = nil
	file_testpb_unknonwnproto_proto_goTypes = nil
	file_testpb_unknonwnproto_proto_depIdxs = nil
}
