// Code generated by protoc-gen-go-lite. DO NOT EDIT.
// protoc-gen-go-lite version: v0.8.1
// source: github.com/aperturerobotics/protobuf-go-lite/testproto/proto2/scalars.proto

package proto2

import (
	base64 "encoding/base64"
	binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	slices "slices"
	strconv "strconv"
	strings "strings"
	unsafe "unsafe"

	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
)

type EnumMessage_Num int32

const (
	EnumMessage_TEN   EnumMessage_Num = 10
	EnumMessage_NINE  EnumMessage_Num = 9
	EnumMessage_EIGHT EnumMessage_Num = 8
	EnumMessage_SEVEN EnumMessage_Num = 7
)

// Enum value maps for EnumMessage_Num.
var (
	EnumMessage_Num_name = map[int32]string{
		10: "TEN",
		9:  "NINE",
		8:  "EIGHT",
		7:  "SEVEN",
	}
	EnumMessage_Num_value = map[string]int32{
		"TEN":   10,
		"NINE":  9,
		"EIGHT": 8,
		"SEVEN": 7,
	}
)

func (x EnumMessage_Num) Enum() *EnumMessage_Num {
	p := new(EnumMessage_Num)
	*p = x
	return p
}

func (x EnumMessage_Num) String() string {
	name, valid := EnumMessage_Num_name[int32(x)]
	if valid {
		return name
	}
	return strconv.Itoa(int(x))
}

type DoubleMessage struct {
	unknownFields []byte
	RequiredField *float64  `protobuf:"fixed64,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *float64  `protobuf:"fixed64,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []float64 `protobuf:"fixed64,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []float64 `protobuf:"fixed64,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for DoubleMessage fields.
const (
	Default_DoubleMessage_RequiredField = float64(1)
	Default_DoubleMessage_OptionalField = float64(2)
)

func (x *DoubleMessage) Reset() {
	*x = DoubleMessage{}
}

func (*DoubleMessage) ProtoMessage() {}

func (x *DoubleMessage) GetRequiredField() float64 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_DoubleMessage_RequiredField
}

func (x *DoubleMessage) GetOptionalField() float64 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_DoubleMessage_OptionalField
}

func (x *DoubleMessage) GetRepeatedField() []float64 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *DoubleMessage) GetPackedField() []float64 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type FloatMessage struct {
	unknownFields []byte
	RequiredField *float32  `protobuf:"fixed32,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *float32  `protobuf:"fixed32,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []float32 `protobuf:"fixed32,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []float32 `protobuf:"fixed32,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for FloatMessage fields.
const (
	Default_FloatMessage_RequiredField = float32(1)
	Default_FloatMessage_OptionalField = float32(2)
)

func (x *FloatMessage) Reset() {
	*x = FloatMessage{}
}

func (*FloatMessage) ProtoMessage() {}

func (x *FloatMessage) GetRequiredField() float32 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_FloatMessage_RequiredField
}

func (x *FloatMessage) GetOptionalField() float32 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_FloatMessage_OptionalField
}

func (x *FloatMessage) GetRepeatedField() []float32 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *FloatMessage) GetPackedField() []float32 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Int32Message struct {
	unknownFields []byte
	RequiredField *int32  `protobuf:"varint,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *int32  `protobuf:"varint,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []int32 `protobuf:"varint,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []int32 `protobuf:"varint,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Int32Message fields.
const (
	Default_Int32Message_RequiredField = int32(1)
	Default_Int32Message_OptionalField = int32(2)
)

func (x *Int32Message) Reset() {
	*x = Int32Message{}
}

func (*Int32Message) ProtoMessage() {}

func (x *Int32Message) GetRequiredField() int32 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Int32Message_RequiredField
}

func (x *Int32Message) GetOptionalField() int32 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Int32Message_OptionalField
}

func (x *Int32Message) GetRepeatedField() []int32 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Int32Message) GetPackedField() []int32 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Int64Message struct {
	unknownFields []byte
	RequiredField *int64  `protobuf:"varint,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *int64  `protobuf:"varint,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []int64 `protobuf:"varint,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []int64 `protobuf:"varint,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Int64Message fields.
const (
	Default_Int64Message_RequiredField = int64(1)
	Default_Int64Message_OptionalField = int64(2)
)

func (x *Int64Message) Reset() {
	*x = Int64Message{}
}

func (*Int64Message) ProtoMessage() {}

func (x *Int64Message) GetRequiredField() int64 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Int64Message_RequiredField
}

func (x *Int64Message) GetOptionalField() int64 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Int64Message_OptionalField
}

func (x *Int64Message) GetRepeatedField() []int64 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Int64Message) GetPackedField() []int64 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Uint32Message struct {
	unknownFields []byte
	RequiredField *uint32  `protobuf:"varint,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *uint32  `protobuf:"varint,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []uint32 `protobuf:"varint,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []uint32 `protobuf:"varint,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Uint32Message fields.
const (
	Default_Uint32Message_RequiredField = uint32(1)
	Default_Uint32Message_OptionalField = uint32(2)
)

func (x *Uint32Message) Reset() {
	*x = Uint32Message{}
}

func (*Uint32Message) ProtoMessage() {}

func (x *Uint32Message) GetRequiredField() uint32 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Uint32Message_RequiredField
}

func (x *Uint32Message) GetOptionalField() uint32 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Uint32Message_OptionalField
}

func (x *Uint32Message) GetRepeatedField() []uint32 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Uint32Message) GetPackedField() []uint32 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Uint64Message struct {
	unknownFields []byte
	RequiredField *uint64  `protobuf:"varint,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *uint64  `protobuf:"varint,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []uint64 `protobuf:"varint,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []uint64 `protobuf:"varint,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Uint64Message fields.
const (
	Default_Uint64Message_RequiredField = uint64(1)
	Default_Uint64Message_OptionalField = uint64(2)
)

func (x *Uint64Message) Reset() {
	*x = Uint64Message{}
}

func (*Uint64Message) ProtoMessage() {}

func (x *Uint64Message) GetRequiredField() uint64 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Uint64Message_RequiredField
}

func (x *Uint64Message) GetOptionalField() uint64 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Uint64Message_OptionalField
}

func (x *Uint64Message) GetRepeatedField() []uint64 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Uint64Message) GetPackedField() []uint64 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Sint32Message struct {
	unknownFields []byte
	RequiredField *int32  `protobuf:"zigzag32,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *int32  `protobuf:"zigzag32,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []int32 `protobuf:"zigzag32,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []int32 `protobuf:"zigzag32,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Sint32Message fields.
const (
	Default_Sint32Message_RequiredField = int32(1)
	Default_Sint32Message_OptionalField = int32(2)
)

func (x *Sint32Message) Reset() {
	*x = Sint32Message{}
}

func (*Sint32Message) ProtoMessage() {}

func (x *Sint32Message) GetRequiredField() int32 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Sint32Message_RequiredField
}

func (x *Sint32Message) GetOptionalField() int32 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Sint32Message_OptionalField
}

func (x *Sint32Message) GetRepeatedField() []int32 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Sint32Message) GetPackedField() []int32 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Sint64Message struct {
	unknownFields []byte
	RequiredField *int64  `protobuf:"zigzag64,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *int64  `protobuf:"zigzag64,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []int64 `protobuf:"zigzag64,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []int64 `protobuf:"zigzag64,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Sint64Message fields.
const (
	Default_Sint64Message_RequiredField = int64(1)
	Default_Sint64Message_OptionalField = int64(2)
)

func (x *Sint64Message) Reset() {
	*x = Sint64Message{}
}

func (*Sint64Message) ProtoMessage() {}

func (x *Sint64Message) GetRequiredField() int64 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Sint64Message_RequiredField
}

func (x *Sint64Message) GetOptionalField() int64 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Sint64Message_OptionalField
}

func (x *Sint64Message) GetRepeatedField() []int64 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Sint64Message) GetPackedField() []int64 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Fixed32Message struct {
	unknownFields []byte
	RequiredField *uint32  `protobuf:"fixed32,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *uint32  `protobuf:"fixed32,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []uint32 `protobuf:"fixed32,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []uint32 `protobuf:"fixed32,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Fixed32Message fields.
const (
	Default_Fixed32Message_RequiredField = uint32(1)
	Default_Fixed32Message_OptionalField = uint32(2)
)

func (x *Fixed32Message) Reset() {
	*x = Fixed32Message{}
}

func (*Fixed32Message) ProtoMessage() {}

func (x *Fixed32Message) GetRequiredField() uint32 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Fixed32Message_RequiredField
}

func (x *Fixed32Message) GetOptionalField() uint32 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Fixed32Message_OptionalField
}

func (x *Fixed32Message) GetRepeatedField() []uint32 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Fixed32Message) GetPackedField() []uint32 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Fixed64Message struct {
	unknownFields []byte
	RequiredField *uint64  `protobuf:"fixed64,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *uint64  `protobuf:"fixed64,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []uint64 `protobuf:"fixed64,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []uint64 `protobuf:"fixed64,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Fixed64Message fields.
const (
	Default_Fixed64Message_RequiredField = uint64(1)
	Default_Fixed64Message_OptionalField = uint64(2)
)

func (x *Fixed64Message) Reset() {
	*x = Fixed64Message{}
}

func (*Fixed64Message) ProtoMessage() {}

func (x *Fixed64Message) GetRequiredField() uint64 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Fixed64Message_RequiredField
}

func (x *Fixed64Message) GetOptionalField() uint64 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Fixed64Message_OptionalField
}

func (x *Fixed64Message) GetRepeatedField() []uint64 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Fixed64Message) GetPackedField() []uint64 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Sfixed32Message struct {
	unknownFields []byte
	RequiredField *int32  `protobuf:"fixed32,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *int32  `protobuf:"fixed32,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []int32 `protobuf:"fixed32,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []int32 `protobuf:"fixed32,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Sfixed32Message fields.
const (
	Default_Sfixed32Message_RequiredField = int32(1)
	Default_Sfixed32Message_OptionalField = int32(2)
)

func (x *Sfixed32Message) Reset() {
	*x = Sfixed32Message{}
}

func (*Sfixed32Message) ProtoMessage() {}

func (x *Sfixed32Message) GetRequiredField() int32 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Sfixed32Message_RequiredField
}

func (x *Sfixed32Message) GetOptionalField() int32 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Sfixed32Message_OptionalField
}

func (x *Sfixed32Message) GetRepeatedField() []int32 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Sfixed32Message) GetPackedField() []int32 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type Sfixed64Message struct {
	unknownFields []byte
	RequiredField *int64  `protobuf:"fixed64,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *int64  `protobuf:"fixed64,2,opt,name=optional_field,json=optionalField,def=2" json:"optionalField,omitempty"`
	RepeatedField []int64 `protobuf:"fixed64,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []int64 `protobuf:"fixed64,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for Sfixed64Message fields.
const (
	Default_Sfixed64Message_RequiredField = int64(1)
	Default_Sfixed64Message_OptionalField = int64(2)
)

func (x *Sfixed64Message) Reset() {
	*x = Sfixed64Message{}
}

func (*Sfixed64Message) ProtoMessage() {}

func (x *Sfixed64Message) GetRequiredField() int64 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_Sfixed64Message_RequiredField
}

func (x *Sfixed64Message) GetOptionalField() int64 {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_Sfixed64Message_OptionalField
}

func (x *Sfixed64Message) GetRepeatedField() []int64 {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *Sfixed64Message) GetPackedField() []int64 {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type BoolMessage struct {
	unknownFields []byte
	RequiredField *bool  `protobuf:"varint,1,req,name=required_field,json=requiredField,def=1" json:"requiredField,omitempty"`
	OptionalField *bool  `protobuf:"varint,2,opt,name=optional_field,json=optionalField" json:"optionalField,omitempty"`
	RepeatedField []bool `protobuf:"varint,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []bool `protobuf:"varint,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for BoolMessage fields.
const (
	Default_BoolMessage_RequiredField = bool(true)
)

func (x *BoolMessage) Reset() {
	*x = BoolMessage{}
}

func (*BoolMessage) ProtoMessage() {}

func (x *BoolMessage) GetRequiredField() bool {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_BoolMessage_RequiredField
}

func (x *BoolMessage) GetOptionalField() bool {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return false
}

func (x *BoolMessage) GetRepeatedField() []bool {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *BoolMessage) GetPackedField() []bool {
	if x != nil {
		return x.PackedField
	}
	return nil
}

type StringMessage struct {
	unknownFields []byte
	RequiredField *string  `protobuf:"bytes,1,req,name=required_field,json=requiredField,def=req" json:"requiredField,omitempty"`
	OptionalField *string  `protobuf:"bytes,2,opt,name=optional_field,json=optionalField,def=opt" json:"optionalField,omitempty"`
	RepeatedField []string `protobuf:"bytes,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
}

// Default values for StringMessage fields.
const (
	Default_StringMessage_RequiredField = string("req")
	Default_StringMessage_OptionalField = string("opt")
)

func (x *StringMessage) Reset() {
	*x = StringMessage{}
}

func (*StringMessage) ProtoMessage() {}

func (x *StringMessage) GetRequiredField() string {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_StringMessage_RequiredField
}

func (x *StringMessage) GetOptionalField() string {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return Default_StringMessage_OptionalField
}

func (x *StringMessage) GetRepeatedField() []string {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

type BytesMessage struct {
	unknownFields []byte
	RequiredField []byte   `protobuf:"bytes,1,req,name=required_field,json=requiredField,def=req" json:"requiredField,omitempty"`
	OptionalField []byte   `protobuf:"bytes,2,opt,name=optional_field,json=optionalField,def=opt" json:"optionalField,omitempty"`
	RepeatedField [][]byte `protobuf:"bytes,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
}

// Default values for BytesMessage fields.
var (
	Default_BytesMessage_RequiredField = []byte("req")
	Default_BytesMessage_OptionalField = []byte("opt")
)

func (x *BytesMessage) Reset() {
	*x = BytesMessage{}
}

func (*BytesMessage) ProtoMessage() {}

func (x *BytesMessage) GetRequiredField() []byte {
	if x != nil && x.RequiredField != nil {
		return x.RequiredField
	}
	return append([]byte(nil), Default_BytesMessage_RequiredField...)
}

func (x *BytesMessage) GetOptionalField() []byte {
	if x != nil && x.OptionalField != nil {
		return x.OptionalField
	}
	return append([]byte(nil), Default_BytesMessage_OptionalField...)
}

func (x *BytesMessage) GetRepeatedField() [][]byte {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

type EnumMessage struct {
	unknownFields []byte
	RequiredField *EnumMessage_Num  `protobuf:"varint,1,req,name=required_field,json=requiredField,def=7" json:"requiredField,omitempty"`
	OptionalField *EnumMessage_Num  `protobuf:"varint,2,opt,name=optional_field,json=optionalField" json:"optionalField,omitempty"`
	RepeatedField []EnumMessage_Num `protobuf:"varint,3,rep,name=repeated_field,json=repeatedField" json:"repeatedField,omitempty"`
	PackedField   []EnumMessage_Num `protobuf:"varint,4,rep,packed,name=packed_field,json=packedField" json:"packedField,omitempty"`
}

// Default values for EnumMessage fields.
const (
	Default_EnumMessage_RequiredField = EnumMessage_SEVEN
)

func (x *EnumMessage) Reset() {
	*x = EnumMessage{}
}

func (*EnumMessage) ProtoMessage() {}

func (x *EnumMessage) GetRequiredField() EnumMessage_Num {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return Default_EnumMessage_RequiredField
}

func (x *EnumMessage) GetOptionalField() EnumMessage_Num {
	if x != nil && x.OptionalField != nil {
		return *x.OptionalField
	}
	return EnumMessage_TEN
}

func (x *EnumMessage) GetRepeatedField() []EnumMessage_Num {
	if x != nil {
		return x.RepeatedField
	}
	return nil
}

func (x *EnumMessage) GetPackedField() []EnumMessage_Num {
	if x != nil {
		return x.PackedField
	}
	return nil
}

func (m *DoubleMessage) CloneVT() *DoubleMessage {
	if m == nil {
		return (*DoubleMessage)(nil)
	}
	r := new(DoubleMessage)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *DoubleMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *FloatMessage) CloneVT() *FloatMessage {
	if m == nil {
		return (*FloatMessage)(nil)
	}
	r := new(FloatMessage)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *FloatMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Int32Message) CloneVT() *Int32Message {
	if m == nil {
		return (*Int32Message)(nil)
	}
	r := new(Int32Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Int32Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Int64Message) CloneVT() *Int64Message {
	if m == nil {
		return (*Int64Message)(nil)
	}
	r := new(Int64Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Int64Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Uint32Message) CloneVT() *Uint32Message {
	if m == nil {
		return (*Uint32Message)(nil)
	}
	r := new(Uint32Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Uint32Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Uint64Message) CloneVT() *Uint64Message {
	if m == nil {
		return (*Uint64Message)(nil)
	}
	r := new(Uint64Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Uint64Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Sint32Message) CloneVT() *Sint32Message {
	if m == nil {
		return (*Sint32Message)(nil)
	}
	r := new(Sint32Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Sint32Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Sint64Message) CloneVT() *Sint64Message {
	if m == nil {
		return (*Sint64Message)(nil)
	}
	r := new(Sint64Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Sint64Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Fixed32Message) CloneVT() *Fixed32Message {
	if m == nil {
		return (*Fixed32Message)(nil)
	}
	r := new(Fixed32Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Fixed32Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Fixed64Message) CloneVT() *Fixed64Message {
	if m == nil {
		return (*Fixed64Message)(nil)
	}
	r := new(Fixed64Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Fixed64Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Sfixed32Message) CloneVT() *Sfixed32Message {
	if m == nil {
		return (*Sfixed32Message)(nil)
	}
	r := new(Sfixed32Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Sfixed32Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *Sfixed64Message) CloneVT() *Sfixed64Message {
	if m == nil {
		return (*Sfixed64Message)(nil)
	}
	r := new(Sfixed64Message)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *Sfixed64Message) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *BoolMessage) CloneVT() *BoolMessage {
	if m == nil {
		return (*BoolMessage)(nil)
	}
	r := new(BoolMessage)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *BoolMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *StringMessage) CloneVT() *StringMessage {
	if m == nil {
		return (*StringMessage)(nil)
	}
	r := new(StringMessage)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *StringMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *BytesMessage) CloneVT() *BytesMessage {
	if m == nil {
		return (*BytesMessage)(nil)
	}
	r := new(BytesMessage)
	if rhs := m.RequiredField; rhs != nil {
		r.RequiredField = slices.Clone(rhs)
	}
	if rhs := m.OptionalField; rhs != nil {
		r.OptionalField = slices.Clone(rhs)
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = make([][]byte, len(rhs))
		for k, v := range rhs {
			r.RepeatedField[k] = slices.Clone(v)
		}
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *BytesMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *EnumMessage) CloneVT() *EnumMessage {
	if m == nil {
		return (*EnumMessage)(nil)
	}
	r := new(EnumMessage)
	if rhs := m.RequiredField; rhs != nil {
		tmpVal := *rhs
		r.RequiredField = &tmpVal
	}
	if rhs := m.OptionalField; rhs != nil {
		tmpVal := *rhs
		r.OptionalField = &tmpVal
	}
	if rhs := m.RepeatedField; rhs != nil {
		r.RepeatedField = slices.Clone(rhs)
	}
	if rhs := m.PackedField; rhs != nil {
		r.PackedField = slices.Clone(rhs)
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *EnumMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (this *DoubleMessage) EqualVT(that *DoubleMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *DoubleMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*DoubleMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *FloatMessage) EqualVT(that *FloatMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *FloatMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*FloatMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Int32Message) EqualVT(that *Int32Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Int32Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Int32Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Int64Message) EqualVT(that *Int64Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Int64Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Int64Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Uint32Message) EqualVT(that *Uint32Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Uint32Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Uint32Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Uint64Message) EqualVT(that *Uint64Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Uint64Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Uint64Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Sint32Message) EqualVT(that *Sint32Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Sint32Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Sint32Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Sint64Message) EqualVT(that *Sint64Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Sint64Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Sint64Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Fixed32Message) EqualVT(that *Fixed32Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Fixed32Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Fixed32Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Fixed64Message) EqualVT(that *Fixed64Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Fixed64Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Fixed64Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Sfixed32Message) EqualVT(that *Sfixed32Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Sfixed32Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Sfixed32Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *Sfixed64Message) EqualVT(that *Sfixed64Message) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *Sfixed64Message) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*Sfixed64Message)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *BoolMessage) EqualVT(that *BoolMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *BoolMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*BoolMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *StringMessage) EqualVT(that *StringMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *StringMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*StringMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *BytesMessage) EqualVT(that *BytesMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && q == nil) || string(p) != string(q) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && q == nil) || string(p) != string(q) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if string(vx) != string(vy) {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *BytesMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*BytesMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *EnumMessage) EqualVT(that *EnumMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.RequiredField, that.RequiredField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.OptionalField, that.OptionalField; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if len(this.RepeatedField) != len(that.RepeatedField) {
		return false
	}
	for i, vx := range this.RepeatedField {
		vy := that.RepeatedField[i]
		if vx != vy {
			return false
		}
	}
	if len(this.PackedField) != len(that.PackedField) {
		return false
	}
	for i, vx := range this.PackedField {
		vy := that.PackedField[i]
		if vx != vy {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *EnumMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*EnumMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

// NOTE: protobuf-go-lite json only supports proto3: proto2 is not supported.

func (m *DoubleMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DoubleMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *DoubleMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float64bits(float64(m.PackedField[iNdEx]))
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*8))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			f2 := math.Float64bits(float64(m.RepeatedField[iNdEx]))
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(f2))
			i--
			dAtA[i] = 0x19
		}
	}
	if m.OptionalField != nil {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.OptionalField))))
		i--
		dAtA[i] = 0x11
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.RequiredField))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *FloatMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FloatMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *FloatMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float32bits(float32(m.PackedField[iNdEx]))
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(f1))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*4))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			f2 := math.Float32bits(float32(m.RepeatedField[iNdEx]))
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(f2))
			i--
			dAtA[i] = 0x1d
		}
	}
	if m.OptionalField != nil {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.OptionalField))))
		i--
		dAtA[i] = 0x15
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.RequiredField))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *Int32Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Int32Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Int32Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.PackedField {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Int64Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Int64Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Int64Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.PackedField {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Uint32Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Uint32Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Uint32Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Uint64Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Uint64Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Uint64Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Sint32Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sint32Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Sint32Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfZigzag(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			x3 := (uint32(num) << 1) ^ uint32((num >> 31))
			for x3 >= 1<<7 {
				dAtA[j1] = uint8(uint64(x3)&0x7f | 0x80)
				j1++
				x3 >>= 7
			}
			dAtA[j1] = uint8(x3)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			x4 := (uint32(m.RepeatedField[iNdEx]) << 1) ^ uint32((m.RepeatedField[iNdEx] >> 31))
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(x4))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint32(*m.OptionalField)<<1)^uint32((*m.OptionalField>>31))))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint32(*m.RequiredField)<<1)^uint32((*m.RequiredField>>31))))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Sint64Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sint64Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Sint64Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfZigzag(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			x3 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x3 >= 1<<7 {
				dAtA[j1] = uint8(uint64(x3)&0x7f | 0x80)
				j1++
				x3 >>= 7
			}
			dAtA[j1] = uint8(x3)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			x4 := (uint64(m.RepeatedField[iNdEx]) << 1) ^ uint64((m.RepeatedField[iNdEx] >> 63))
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(x4))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint64(*m.OptionalField)<<1)^uint64((*m.OptionalField>>63))))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint64(*m.RequiredField)<<1)^uint64((*m.RequiredField>>63))))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Fixed32Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Fixed32Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Fixed32Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*4))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x1d
		}
	}
	if m.OptionalField != nil {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.OptionalField))
		i--
		dAtA[i] = 0x15
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.RequiredField))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *Fixed64Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Fixed64Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Fixed64Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*8))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x19
		}
	}
	if m.OptionalField != nil {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x11
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *Sfixed32Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sfixed32Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Sfixed32Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*4))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x1d
		}
	}
	if m.OptionalField != nil {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.OptionalField))
		i--
		dAtA[i] = 0x15
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.RequiredField))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *Sfixed64Message) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sfixed64Message) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *Sfixed64Message) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*8))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x19
		}
	}
	if m.OptionalField != nil {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x11
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *BoolMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BoolMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *BoolMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.PackedField[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.RepeatedField[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i--
		if *m.OptionalField {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i--
		if *m.RequiredField {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StringMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StringMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *StringMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RepeatedField[iNdEx])
			copy(dAtA[i:], m.RepeatedField[iNdEx])
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.RepeatedField[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.OptionalField != nil {
		i -= len(*m.OptionalField)
		copy(dAtA[i:], *m.OptionalField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(*m.OptionalField)))
		i--
		dAtA[i] = 0x12
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= len(*m.RequiredField)
		copy(dAtA[i:], *m.RequiredField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(*m.RequiredField)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BytesMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BytesMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *BytesMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RepeatedField[iNdEx])
			copy(dAtA[i:], m.RepeatedField[iNdEx])
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.RepeatedField[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.OptionalField != nil {
		i -= len(m.OptionalField)
		copy(dAtA[i:], m.OptionalField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.OptionalField)))
		i--
		dAtA[i] = 0x12
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= len(m.RequiredField)
		copy(dAtA[i:], m.RequiredField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.RequiredField)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EnumMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EnumMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *EnumMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.PackedField {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DoubleMessage) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DoubleMessage) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *DoubleMessage) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float64bits(float64(m.PackedField[iNdEx]))
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(f1))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*8))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			f2 := math.Float64bits(float64(m.RepeatedField[iNdEx]))
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(f2))
			i--
			dAtA[i] = 0x19
		}
	}
	if m.OptionalField != nil {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.OptionalField))))
		i--
		dAtA[i] = 0x11
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(*m.RequiredField))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *FloatMessage) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FloatMessage) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *FloatMessage) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			f1 := math.Float32bits(float32(m.PackedField[iNdEx]))
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(f1))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*4))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			f2 := math.Float32bits(float32(m.RepeatedField[iNdEx]))
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(f2))
			i--
			dAtA[i] = 0x1d
		}
	}
	if m.OptionalField != nil {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.OptionalField))))
		i--
		dAtA[i] = 0x15
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(*m.RequiredField))))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *Int32Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Int32Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Int32Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.PackedField {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Int64Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Int64Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Int64Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.PackedField {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Uint32Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Uint32Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Uint32Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Uint64Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Uint64Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Uint64Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Sint32Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sint32Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Sint32Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfZigzag(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			x3 := (uint32(num) << 1) ^ uint32((num >> 31))
			for x3 >= 1<<7 {
				dAtA[j1] = uint8(uint64(x3)&0x7f | 0x80)
				j1++
				x3 >>= 7
			}
			dAtA[j1] = uint8(x3)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			x4 := (uint32(m.RepeatedField[iNdEx]) << 1) ^ uint32((m.RepeatedField[iNdEx] >> 31))
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(x4))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint32(*m.OptionalField)<<1)^uint32((*m.OptionalField>>31))))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint32(*m.RequiredField)<<1)^uint32((*m.RequiredField>>31))))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Sint64Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sint64Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Sint64Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfZigzag(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num := range m.PackedField {
			x3 := (uint64(num) << 1) ^ uint64((num >> 63))
			for x3 >= 1<<7 {
				dAtA[j1] = uint8(uint64(x3)&0x7f | 0x80)
				j1++
				x3 >>= 7
			}
			dAtA[j1] = uint8(x3)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			x4 := (uint64(m.RepeatedField[iNdEx]) << 1) ^ uint64((m.RepeatedField[iNdEx] >> 63))
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(x4))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint64(*m.OptionalField)<<1)^uint64((*m.OptionalField>>63))))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64((uint64(*m.RequiredField)<<1)^uint64((*m.RequiredField>>63))))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Fixed32Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Fixed32Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Fixed32Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*4))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x1d
		}
	}
	if m.OptionalField != nil {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.OptionalField))
		i--
		dAtA[i] = 0x15
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.RequiredField))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *Fixed64Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Fixed64Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Fixed64Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*8))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x19
		}
	}
	if m.OptionalField != nil {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x11
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *Sfixed32Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sfixed32Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Sfixed32Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*4))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 4
			binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x1d
		}
	}
	if m.OptionalField != nil {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.OptionalField))
		i--
		dAtA[i] = 0x15
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 4
		binary.LittleEndian.PutUint32(dAtA[i:], uint32(*m.RequiredField))
		i--
		dAtA[i] = 0xd
	}
	return len(dAtA) - i, nil
}

func (m *Sfixed64Message) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Sfixed64Message) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *Sfixed64Message) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.PackedField[iNdEx]))
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)*8))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= 8
			binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x19
		}
	}
	if m.OptionalField != nil {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x11
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *BoolMessage) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BoolMessage) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *BoolMessage) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		for iNdEx := len(m.PackedField) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.PackedField[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.PackedField)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.RepeatedField[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i--
		if *m.OptionalField {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i--
		if *m.RequiredField {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StringMessage) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StringMessage) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *StringMessage) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RepeatedField[iNdEx])
			copy(dAtA[i:], m.RepeatedField[iNdEx])
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.RepeatedField[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.OptionalField != nil {
		i -= len(*m.OptionalField)
		copy(dAtA[i:], *m.OptionalField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(*m.OptionalField)))
		i--
		dAtA[i] = 0x12
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= len(*m.RequiredField)
		copy(dAtA[i:], *m.RequiredField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(*m.RequiredField)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BytesMessage) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BytesMessage) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *BytesMessage) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RepeatedField[iNdEx])
			copy(dAtA[i:], m.RepeatedField[iNdEx])
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.RepeatedField[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.OptionalField != nil {
		i -= len(m.OptionalField)
		copy(dAtA[i:], m.OptionalField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.OptionalField)))
		i--
		dAtA[i] = 0x12
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i -= len(m.RequiredField)
		copy(dAtA[i:], m.RequiredField)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.RequiredField)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EnumMessage) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EnumMessage) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *EnumMessage) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.PackedField) > 0 {
		var pksize2 int
		for _, num := range m.PackedField {
			pksize2 += protobuf_go_lite.SizeOfVarint(uint64(num))
		}
		i -= pksize2
		j1 := i
		for _, num1 := range m.PackedField {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA[j1] = uint8(num)
			j1++
		}
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(pksize2))
		i--
		dAtA[i] = 0x22
	}
	if len(m.RepeatedField) > 0 {
		for iNdEx := len(m.RepeatedField) - 1; iNdEx >= 0; iNdEx-- {
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.RepeatedField[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	if m.OptionalField != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.OptionalField))
		i--
		dAtA[i] = 0x10
	}
	if m.RequiredField == nil {
		return 0, fmt.Errorf("proto: required field required_field not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RequiredField))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *DoubleMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 9
	}
	if m.OptionalField != nil {
		n += 9
	}
	if len(m.RepeatedField) > 0 {
		n += 9 * len(m.RepeatedField)
	}
	if len(m.PackedField) > 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(len(m.PackedField)*8)) + len(m.PackedField)*8
	}
	n += len(m.unknownFields)
	return n
}

func (m *FloatMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 5
	}
	if m.OptionalField != nil {
		n += 5
	}
	if len(m.RepeatedField) > 0 {
		n += 5 * len(m.RepeatedField)
	}
	if len(m.PackedField) > 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(len(m.PackedField)*4)) + len(m.PackedField)*4
	}
	n += len(m.unknownFields)
	return n
}

func (m *Int32Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.RequiredField))
	}
	if m.OptionalField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.OptionalField))
	}
	if len(m.RepeatedField) > 0 {
		for _, e := range m.RepeatedField {
			n += 1 + protobuf_go_lite.SizeOfVarint(uint64(e))
		}
	}
	if len(m.PackedField) > 0 {
		l = 0
		for _, e := range m.PackedField {
			l += protobuf_go_lite.SizeOfVarint(uint64(e))
		}
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	n += len(m.unknownFields)
	return n
}

func (m *Int64Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.RequiredField))
	}
	if m.OptionalField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.OptionalField))
	}
	if len(m.RepeatedField) > 0 {
		for _, e := range m.RepeatedField {
			n += 1 + protobuf_go_lite.SizeOfVarint(uint64(e))
		}
	}
	if len(m.PackedField) > 0 {
		l = 0
		for _, e := range m.PackedField {
			l += protobuf_go_lite.SizeOfVarint(uint64(e))
		}
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	n += len(m.unknownFields)
	return n
}

func (m *Uint32Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.RequiredField))
	}
	if m.OptionalField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.OptionalField))
	}
	if len(m.RepeatedField) > 0 {
		for _, e := range m.RepeatedField {
			n += 1 + protobuf_go_lite.SizeOfVarint(uint64(e))
		}
	}
	if len(m.PackedField) > 0 {
		l = 0
		for _, e := range m.PackedField {
			l += protobuf_go_lite.SizeOfVarint(uint64(e))
		}
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	n += len(m.unknownFields)
	return n
}

func (m *Uint64Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.RequiredField))
	}
	if m.OptionalField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.OptionalField))
	}
	if len(m.RepeatedField) > 0 {
		for _, e := range m.RepeatedField {
			n += 1 + protobuf_go_lite.SizeOfVarint(uint64(e))
		}
	}
	if len(m.PackedField) > 0 {
		l = 0
		for _, e := range m.PackedField {
			l += protobuf_go_lite.SizeOfVarint(uint64(e))
		}
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	n += len(m.unknownFields)
	return n
}

func (m *Sint32Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(*m.RequiredField))
	}
	if m.OptionalField != nil {
		n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(*m.OptionalField))
	}
	if len(m.RepeatedField) > 0 {
		for _, e := range m.RepeatedField {
			n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(e))
		}
	}
	if len(m.PackedField) > 0 {
		l = 0
		for _, e := range m.PackedField {
			l += protobuf_go_lite.SizeOfZigzag(uint64(e))
		}
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	n += len(m.unknownFields)
	return n
}

func (m *Sint64Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(*m.RequiredField))
	}
	if m.OptionalField != nil {
		n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(*m.OptionalField))
	}
	if len(m.RepeatedField) > 0 {
		for _, e := range m.RepeatedField {
			n += 1 + protobuf_go_lite.SizeOfZigzag(uint64(e))
		}
	}
	if len(m.PackedField) > 0 {
		l = 0
		for _, e := range m.PackedField {
			l += protobuf_go_lite.SizeOfZigzag(uint64(e))
		}
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	n += len(m.unknownFields)
	return n
}

func (m *Fixed32Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 5
	}
	if m.OptionalField != nil {
		n += 5
	}
	if len(m.RepeatedField) > 0 {
		n += 5 * len(m.RepeatedField)
	}
	if len(m.PackedField) > 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(len(m.PackedField)*4)) + len(m.PackedField)*4
	}
	n += len(m.unknownFields)
	return n
}

func (m *Fixed64Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 9
	}
	if m.OptionalField != nil {
		n += 9
	}
	if len(m.RepeatedField) > 0 {
		n += 9 * len(m.RepeatedField)
	}
	if len(m.PackedField) > 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(len(m.PackedField)*8)) + len(m.PackedField)*8
	}
	n += len(m.unknownFields)
	return n
}

func (m *Sfixed32Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 5
	}
	if m.OptionalField != nil {
		n += 5
	}
	if len(m.RepeatedField) > 0 {
		n += 5 * len(m.RepeatedField)
	}
	if len(m.PackedField) > 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(len(m.PackedField)*4)) + len(m.PackedField)*4
	}
	n += len(m.unknownFields)
	return n
}

func (m *Sfixed64Message) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 9
	}
	if m.OptionalField != nil {
		n += 9
	}
	if len(m.RepeatedField) > 0 {
		n += 9 * len(m.RepeatedField)
	}
	if len(m.PackedField) > 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(len(m.PackedField)*8)) + len(m.PackedField)*8
	}
	n += len(m.unknownFields)
	return n
}

func (m *BoolMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 2
	}
	if m.OptionalField != nil {
		n += 2
	}
	if len(m.RepeatedField) > 0 {
		n += 2 * len(m.RepeatedField)
	}
	if len(m.PackedField) > 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(len(m.PackedField))) + len(m.PackedField)*1
	}
	n += len(m.unknownFields)
	return n
}

func (m *StringMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		l = len(*m.RequiredField)
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.OptionalField != nil {
		l = len(*m.OptionalField)
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if len(m.RepeatedField) > 0 {
		for _, s := range m.RepeatedField {
			l = len(s)
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	n += len(m.unknownFields)
	return n
}

func (m *BytesMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		l = len(m.RequiredField)
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.OptionalField != nil {
		l = len(m.OptionalField)
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if len(m.RepeatedField) > 0 {
		for _, b := range m.RepeatedField {
			l = len(b)
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	n += len(m.unknownFields)
	return n
}

func (m *EnumMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RequiredField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.RequiredField))
	}
	if m.OptionalField != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.OptionalField))
	}
	if len(m.RepeatedField) > 0 {
		for _, e := range m.RepeatedField {
			n += 1 + protobuf_go_lite.SizeOfVarint(uint64(e))
		}
	}
	if len(m.PackedField) > 0 {
		l = 0
		for _, e := range m.PackedField {
			l += protobuf_go_lite.SizeOfVarint(uint64(e))
		}
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(l)) + l
	}
	n += len(m.unknownFields)
	return n
}

func (x *DoubleMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("DoubleMessage {")
	if x.RequiredField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatFloat(*x.RequiredField, 'g', -1, 64))
	}
	if x.OptionalField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatFloat(*x.OptionalField, 'g', -1, 64))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatFloat(v, 'g', -1, 64))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatFloat(v, 'g', -1, 64))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *DoubleMessage) String() string {
	return x.MarshalProtoText()
}
func (x *FloatMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("FloatMessage {")
	if x.RequiredField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatFloat(float64(*x.RequiredField), 'g', -1, 32))
	}
	if x.OptionalField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatFloat(float64(*x.OptionalField), 'g', -1, 32))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatFloat(float64(v), 'g', -1, 32))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatFloat(float64(v), 'g', -1, 32))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *FloatMessage) String() string {
	return x.MarshalProtoText()
}
func (x *Int32Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Int32Message {")
	if x.RequiredField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Int32Message) String() string {
	return x.MarshalProtoText()
}
func (x *Int64Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Int64Message {")
	if x.RequiredField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Int64Message) String() string {
	return x.MarshalProtoText()
}
func (x *Uint32Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Uint32Message {")
	if x.RequiredField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Uint32Message) String() string {
	return x.MarshalProtoText()
}
func (x *Uint64Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Uint64Message {")
	if x.RequiredField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Uint64Message) String() string {
	return x.MarshalProtoText()
}
func (x *Sint32Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Sint32Message {")
	if x.RequiredField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Sint32Message) String() string {
	return x.MarshalProtoText()
}
func (x *Sint64Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Sint64Message {")
	if x.RequiredField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Sint64Message) String() string {
	return x.MarshalProtoText()
}
func (x *Fixed32Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Fixed32Message {")
	if x.RequiredField != nil {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Fixed32Message) String() string {
	return x.MarshalProtoText()
}
func (x *Fixed64Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Fixed64Message {")
	if x.RequiredField != nil {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 16 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatUint(uint64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Fixed64Message) String() string {
	return x.MarshalProtoText()
}
func (x *Sfixed32Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Sfixed32Message {")
	if x.RequiredField != nil {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Sfixed32Message) String() string {
	return x.MarshalProtoText()
}
func (x *Sfixed64Message) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("Sfixed64Message {")
	if x.RequiredField != nil {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.RequiredField), 10))
	}
	if x.OptionalField != nil {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatInt(int64(*x.OptionalField), 10))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 17 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatInt(int64(v), 10))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *Sfixed64Message) String() string {
	return x.MarshalProtoText()
}
func (x *BoolMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("BoolMessage {")
	if x.RequiredField != nil {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.FormatBool(*x.RequiredField))
	}
	if x.OptionalField != nil {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.FormatBool(*x.OptionalField))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatBool(v))
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.FormatBool(v))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *BoolMessage) String() string {
	return x.MarshalProtoText()
}
func (x *StringMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("StringMessage {")
	if x.RequiredField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString(strconv.Quote(*x.RequiredField))
	}
	if x.OptionalField != nil {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString(strconv.Quote(*x.OptionalField))
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 15 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(strconv.Quote(v))
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *StringMessage) String() string {
	return x.MarshalProtoText()
}
func (x *BytesMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("BytesMessage {")
	if x.RequiredField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString("\"")
		sb.WriteString(base64.StdEncoding.EncodeToString(x.RequiredField))
		sb.WriteString("\"")
	}
	if x.OptionalField != nil {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString("\"")
		sb.WriteString(base64.StdEncoding.EncodeToString(x.OptionalField))
		sb.WriteString("\"")
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 14 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString("\"")
			sb.WriteString(base64.StdEncoding.EncodeToString(v))
			sb.WriteString("\"")
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *BytesMessage) String() string {
	return x.MarshalProtoText()
}
func (x EnumMessage_Num) MarshalProtoText() string {
	return x.String()
}
func (x *EnumMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("EnumMessage {")
	if x.RequiredField != nil {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("required_field: ")
		sb.WriteString("\"")
		sb.WriteString(x.RequiredField.String())
		sb.WriteString("\"")
	}
	if x.OptionalField != nil {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("optional_field: ")
		sb.WriteString("\"")
		sb.WriteString(x.OptionalField.String())
		sb.WriteString("\"")
	}
	if len(x.RepeatedField) > 0 {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("repeated_field: [")
		for i, v := range x.RepeatedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString("\"")
			sb.WriteString(EnumMessage_Num(v).String())
			sb.WriteString("\"")
		}
		sb.WriteString("]")
	}
	if len(x.PackedField) > 0 {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("packed_field: [")
		for i, v := range x.PackedField {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString("\"")
			sb.WriteString(EnumMessage_Num(v).String())
			sb.WriteString("\"")
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *EnumMessage) String() string {
	return x.MarshalProtoText()
}
func (m *DoubleMessage) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: DoubleMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DoubleMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.RequiredField = &v2
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.OptionalField = &v2
		case 3:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.RepeatedField = append(m.RepeatedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.RepeatedField = append(m.RepeatedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.PackedField = append(m.PackedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.PackedField = append(m.PackedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FloatMessage) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: FloatMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FloatMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			v2 := float32(math.Float32frombits(v))
			m.RequiredField = &v2
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			v2 := float32(math.Float32frombits(v))
			m.OptionalField = &v2
		case 3:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.RepeatedField = append(m.RepeatedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.RepeatedField = append(m.RepeatedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.PackedField = append(m.PackedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.PackedField = append(m.PackedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Int32Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Int32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Int32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Int64Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Int64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Int64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Uint32Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Uint32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Uint32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Uint64Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Uint64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Uint64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sint32Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sint32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sint32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sint64Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sint64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sint64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
			v2 := int64(v)
			m.RequiredField = &v2
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
			v2 := int64(v)
			m.OptionalField = &v2
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
				m.RepeatedField = append(m.RepeatedField, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
					m.RepeatedField = append(m.RepeatedField, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
				m.PackedField = append(m.PackedField, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
					m.PackedField = append(m.PackedField, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fixed32Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Fixed32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fixed32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.OptionalField = &v
		case 3:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fixed64Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Fixed64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fixed64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.OptionalField = &v
		case 3:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sfixed32Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sfixed32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sfixed32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.OptionalField = &v
		case 3:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sfixed64Message) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sfixed64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sfixed64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.OptionalField = &v
		case 3:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BoolMessage) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: BoolMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BoolMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.RequiredField = &b
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.OptionalField = &b
		case 3:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StringMessage) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: StringMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.RequiredField = &s
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(dAtA[iNdEx:postIndex])
			m.OptionalField = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RepeatedField = append(m.RepeatedField, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BytesMessage) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: BytesMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BytesMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequiredField = append(m.RequiredField[:0], dAtA[iNdEx:postIndex]...)
			if m.RequiredField == nil {
				m.RequiredField = []byte{}
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OptionalField = append(m.OptionalField[:0], dAtA[iNdEx:postIndex]...)
			if m.OptionalField == nil {
				m.OptionalField = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RepeatedField = append(m.RepeatedField, make([]byte, postIndex-iNdEx))
			copy(m.RepeatedField[len(m.RepeatedField)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnumMessage) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: EnumMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnumMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v EnumMessage_Num
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= EnumMessage_Num(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v EnumMessage_Num
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= EnumMessage_Num(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v EnumMessage_Num
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= EnumMessage_Num(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]EnumMessage_Num, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v EnumMessage_Num
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= EnumMessage_Num(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v EnumMessage_Num
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= EnumMessage_Num(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]EnumMessage_Num, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v EnumMessage_Num
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= EnumMessage_Num(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DoubleMessage) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: DoubleMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DoubleMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.RequiredField = &v2
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			v2 := float64(math.Float64frombits(v))
			m.OptionalField = &v2
		case 3:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.RepeatedField = append(m.RepeatedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.RepeatedField = append(m.RepeatedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.PackedField = append(m.PackedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.PackedField = append(m.PackedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FloatMessage) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: FloatMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FloatMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			v2 := float32(math.Float32frombits(v))
			m.RequiredField = &v2
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			v2 := float32(math.Float32frombits(v))
			m.OptionalField = &v2
		case 3:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.RepeatedField = append(m.RepeatedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.RepeatedField = append(m.RepeatedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.PackedField = append(m.PackedField, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.PackedField = append(m.PackedField, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Int32Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Int32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Int32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Int64Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Int64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Int64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Uint32Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Uint32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Uint32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v uint32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Uint64Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Uint64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Uint64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sint32Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sint32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sint32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sint64Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sint64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sint64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
			v2 := int64(v)
			m.RequiredField = &v2
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
			v2 := int64(v)
			m.OptionalField = &v2
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
				m.RepeatedField = append(m.RepeatedField, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
					m.RepeatedField = append(m.RepeatedField, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
				m.PackedField = append(m.PackedField, int64(v))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					v = (v >> 1) ^ uint64((int64(v&1)<<63)>>63)
					m.PackedField = append(m.PackedField, int64(v))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fixed32Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Fixed32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fixed32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.OptionalField = &v
		case 3:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Fixed64Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Fixed64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Fixed64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.OptionalField = &v
		case 3:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sfixed32Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sfixed32Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sfixed32Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.OptionalField = &v
		case 3:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 5 {
				var v int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = int32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Sfixed64Message) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: Sfixed64Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Sfixed64Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.OptionalField = &v
		case 3:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 1 {
				var v int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = int64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BoolMessage) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: BoolMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BoolMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.RequiredField = &b
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.OptionalField = &b
		case 3:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StringMessage) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: StringMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var stringValue string
			if intStringLen > 0 {
				stringValue = unsafe.String(&dAtA[iNdEx], intStringLen)
			}
			s := stringValue
			m.RequiredField = &s
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var stringValue string
			if intStringLen > 0 {
				stringValue = unsafe.String(&dAtA[iNdEx], intStringLen)
			}
			s := stringValue
			m.OptionalField = &s
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var stringValue string
			if intStringLen > 0 {
				stringValue = unsafe.String(&dAtA[iNdEx], intStringLen)
			}
			m.RepeatedField = append(m.RepeatedField, stringValue)
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BytesMessage) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: BytesMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BytesMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RequiredField = dAtA[iNdEx:postIndex]
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OptionalField = dAtA[iNdEx:postIndex]
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RepeatedField = append(m.RepeatedField, dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnumMessage) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return 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 fmt.Errorf("proto: EnumMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnumMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredField", wireType)
			}
			var v EnumMessage_Num
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= EnumMessage_Num(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RequiredField = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OptionalField", wireType)
			}
			var v EnumMessage_Num
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= EnumMessage_Num(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OptionalField = &v
		case 3:
			if wireType == 0 {
				var v EnumMessage_Num
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= EnumMessage_Num(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RepeatedField = append(m.RepeatedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.RepeatedField) == 0 {
					m.RepeatedField = make([]EnumMessage_Num, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v EnumMessage_Num
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= EnumMessage_Num(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RepeatedField = append(m.RepeatedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedField", wireType)
			}
		case 4:
			if wireType == 0 {
				var v EnumMessage_Num
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= EnumMessage_Num(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PackedField = append(m.PackedField, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return protobuf_go_lite.ErrIntOverflow
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return protobuf_go_lite.ErrInvalidLength
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.PackedField) == 0 {
					m.PackedField = make([]EnumMessage_Num, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v EnumMessage_Num
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return protobuf_go_lite.ErrIntOverflow
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= EnumMessage_Num(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PackedField = append(m.PackedField, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PackedField", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field required_field not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
