theproto3.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: combos/both/theproto3.proto

package theproto3

import (
	bytes "bytes"
	compress_gzip "compress/gzip"
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	both "github.com/gogo/protobuf/test/combos/both"
	github_com_gogo_protobuf_test_custom "github.com/gogo/protobuf/test/custom"
	io "io"
	io_ioutil "io/ioutil"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type MapEnum int32

const (
	MA MapEnum = 0
	MB MapEnum = 1
	MC MapEnum = 2
)

var MapEnum_name = map[int32]string{
	0: "MA",
	1: "MB",
	2: "MC",
}

var MapEnum_value = map[string]int32{
	"MA": 0,
	"MB": 1,
	"MC": 2,
}

func (MapEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{0}
}

type Message_Humour int32

const (
	UNKNOWN     Message_Humour = 0
	PUNS        Message_Humour = 1
	SLAPSTICK   Message_Humour = 2
	BILL_BAILEY Message_Humour = 3
)

var Message_Humour_name = map[int32]string{
	0: "UNKNOWN",
	1: "PUNS",
	2: "SLAPSTICK",
	3: "BILL_BAILEY",
}

var Message_Humour_value = map[string]int32{
	"UNKNOWN":     0,
	"PUNS":        1,
	"SLAPSTICK":   2,
	"BILL_BAILEY": 3,
}

func (Message_Humour) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{0, 0}
}

type Message struct {
	Name                 string                     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Hilarity             Message_Humour             `protobuf:"varint,2,opt,name=hilarity,proto3,enum=theproto3.Message_Humour" json:"hilarity,omitempty"`
	HeightInCm           uint32                     `protobuf:"varint,3,opt,name=height_in_cm,json=heightInCm,proto3" json:"height_in_cm,omitempty"`
	Data                 []byte                     `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	ResultCount          int64                      `protobuf:"varint,7,opt,name=result_count,json=resultCount,proto3" json:"result_count,omitempty"`
	TrueScotsman         bool                       `protobuf:"varint,8,opt,name=true_scotsman,json=trueScotsman,proto3" json:"true_scotsman,omitempty"`
	Score                float32                    `protobuf:"fixed32,9,opt,name=score,proto3" json:"score,omitempty"`
	Key                  []uint64                   `protobuf:"varint,5,rep,packed,name=key,proto3" json:"key,omitempty"`
	Nested               *Nested                    `protobuf:"bytes,6,opt,name=nested,proto3" json:"nested,omitempty"`
	Terrain              map[int64]*Nested          `protobuf:"bytes,10,rep,name=terrain,proto3" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Proto2Field          *both.NinOptNative         `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field,proto3" json:"proto2_field,omitempty"`
	Proto2Value          map[int64]*both.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value,proto3" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *Message) Reset()      { *m = Message{} }
func (*Message) ProtoMessage() {}
func (*Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{0}
}
func (m *Message) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Message.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Message.Merge(m, src)
}
func (m *Message) XXX_Size() int {
	return m.Size()
}
func (m *Message) XXX_DiscardUnknown() {
	xxx_messageInfo_Message.DiscardUnknown(m)
}

var xxx_messageInfo_Message proto.InternalMessageInfo

type Nested struct {
	Bunny                string   `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Nested) Reset()      { *m = Nested{} }
func (*Nested) ProtoMessage() {}
func (*Nested) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{1}
}
func (m *Nested) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Nested) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Nested.Merge(m, src)
}
func (m *Nested) XXX_Size() int {
	return m.Size()
}
func (m *Nested) XXX_DiscardUnknown() {
	xxx_messageInfo_Nested.DiscardUnknown(m)
}

var xxx_messageInfo_Nested proto.InternalMessageInfo

type AllMaps struct {
	StringToDoubleMap    map[string]float64        `protobuf:"bytes,1,rep,name=StringToDoubleMap,proto3" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	StringToFloatMap     map[string]float32        `protobuf:"bytes,2,rep,name=StringToFloatMap,proto3" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	Int32Map             map[int32]int32           `protobuf:"bytes,3,rep,name=Int32Map,proto3" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Int64Map             map[int64]int64           `protobuf:"bytes,4,rep,name=Int64Map,proto3" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Uint32Map            map[uint32]uint32         `protobuf:"bytes,5,rep,name=Uint32Map,proto3" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Uint64Map            map[uint64]uint64         `protobuf:"bytes,6,rep,name=Uint64Map,proto3" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Sint32Map            map[int32]int32           `protobuf:"bytes,7,rep,name=Sint32Map,proto3" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
	Sint64Map            map[int64]int64           `protobuf:"bytes,8,rep,name=Sint64Map,proto3" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
	Fixed32Map           map[uint32]uint32         `protobuf:"bytes,9,rep,name=Fixed32Map,proto3" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	Sfixed32Map          map[int32]int32           `protobuf:"bytes,10,rep,name=Sfixed32Map,proto3" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	Fixed64Map           map[uint64]uint64         `protobuf:"bytes,11,rep,name=Fixed64Map,proto3" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	Sfixed64Map          map[int64]int64           `protobuf:"bytes,12,rep,name=Sfixed64Map,proto3" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	BoolMap              map[bool]bool             `protobuf:"bytes,13,rep,name=BoolMap,proto3" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	StringMap            map[string]string         `protobuf:"bytes,14,rep,name=StringMap,proto3" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	StringToBytesMap     map[string][]byte         `protobuf:"bytes,15,rep,name=StringToBytesMap,proto3" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	StringToEnumMap      map[string]MapEnum        `protobuf:"bytes,16,rep,name=StringToEnumMap,proto3" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"`
	StringToMsgMap       map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap,proto3" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *AllMaps) Reset()      { *m = AllMaps{} }
func (*AllMaps) ProtoMessage() {}
func (*AllMaps) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{2}
}
func (m *AllMaps) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AllMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AllMaps.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AllMaps) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AllMaps.Merge(m, src)
}
func (m *AllMaps) XXX_Size() int {
	return m.Size()
}
func (m *AllMaps) XXX_DiscardUnknown() {
	xxx_messageInfo_AllMaps.DiscardUnknown(m)
}

var xxx_messageInfo_AllMaps proto.InternalMessageInfo

type AllMapsOrdered struct {
	StringToDoubleMap    map[string]float64        `protobuf:"bytes,1,rep,name=StringToDoubleMap,proto3" json:"StringToDoubleMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	StringToFloatMap     map[string]float32        `protobuf:"bytes,2,rep,name=StringToFloatMap,proto3" json:"StringToFloatMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	Int32Map             map[int32]int32           `protobuf:"bytes,3,rep,name=Int32Map,proto3" json:"Int32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Int64Map             map[int64]int64           `protobuf:"bytes,4,rep,name=Int64Map,proto3" json:"Int64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Uint32Map            map[uint32]uint32         `protobuf:"bytes,5,rep,name=Uint32Map,proto3" json:"Uint32Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Uint64Map            map[uint64]uint64         `protobuf:"bytes,6,rep,name=Uint64Map,proto3" json:"Uint64Map,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Sint32Map            map[int32]int32           `protobuf:"bytes,7,rep,name=Sint32Map,proto3" json:"Sint32Map,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
	Sint64Map            map[int64]int64           `protobuf:"bytes,8,rep,name=Sint64Map,proto3" json:"Sint64Map,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
	Fixed32Map           map[uint32]uint32         `protobuf:"bytes,9,rep,name=Fixed32Map,proto3" json:"Fixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	Sfixed32Map          map[int32]int32           `protobuf:"bytes,10,rep,name=Sfixed32Map,proto3" json:"Sfixed32Map,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
	Fixed64Map           map[uint64]uint64         `protobuf:"bytes,11,rep,name=Fixed64Map,proto3" json:"Fixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	Sfixed64Map          map[int64]int64           `protobuf:"bytes,12,rep,name=Sfixed64Map,proto3" json:"Sfixed64Map,omitempty" protobuf_key:"fixed64,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	BoolMap              map[bool]bool             `protobuf:"bytes,13,rep,name=BoolMap,proto3" json:"BoolMap,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	StringMap            map[string]string         `protobuf:"bytes,14,rep,name=StringMap,proto3" json:"StringMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	StringToBytesMap     map[string][]byte         `protobuf:"bytes,15,rep,name=StringToBytesMap,proto3" json:"StringToBytesMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	StringToEnumMap      map[string]MapEnum        `protobuf:"bytes,16,rep,name=StringToEnumMap,proto3" json:"StringToEnumMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=theproto3.MapEnum"`
	StringToMsgMap       map[string]*FloatingPoint `protobuf:"bytes,17,rep,name=StringToMsgMap,proto3" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *AllMapsOrdered) Reset()      { *m = AllMapsOrdered{} }
func (*AllMapsOrdered) ProtoMessage() {}
func (*AllMapsOrdered) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{3}
}
func (m *AllMapsOrdered) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AllMapsOrdered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (m *AllMapsOrdered) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AllMapsOrdered.Merge(m, src)
}
func (m *AllMapsOrdered) XXX_Size() int {
	return m.Size()
}
func (m *AllMapsOrdered) XXX_DiscardUnknown() {
	xxx_messageInfo_AllMapsOrdered.DiscardUnknown(m)
}

var xxx_messageInfo_AllMapsOrdered proto.InternalMessageInfo

type MessageWithMap struct {
	NameMapping          map[int32]string         `protobuf:"bytes,1,rep,name=name_mapping,json=nameMapping,proto3" json:"name_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MsgMapping           map[int64]*FloatingPoint `protobuf:"bytes,2,rep,name=msg_mapping,json=msgMapping,proto3" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ByteMapping          map[bool][]byte          `protobuf:"bytes,3,rep,name=byte_mapping,json=byteMapping,proto3" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *MessageWithMap) Reset()      { *m = MessageWithMap{} }
func (*MessageWithMap) ProtoMessage() {}
func (*MessageWithMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{4}
}
func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MessageWithMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageWithMap.Merge(m, src)
}
func (m *MessageWithMap) XXX_Size() int {
	return m.Size()
}
func (m *MessageWithMap) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
}

var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo

type FloatingPoint struct {
	F                    float64  `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FloatingPoint) Reset()      { *m = FloatingPoint{} }
func (*FloatingPoint) ProtoMessage() {}
func (*FloatingPoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{5}
}
func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FloatingPoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FloatingPoint.Merge(m, src)
}
func (m *FloatingPoint) XXX_Size() int {
	return m.Size()
}
func (m *FloatingPoint) XXX_DiscardUnknown() {
	xxx_messageInfo_FloatingPoint.DiscardUnknown(m)
}

var xxx_messageInfo_FloatingPoint proto.InternalMessageInfo

type Uint128Pair struct {
	Left                 github_com_gogo_protobuf_test_custom.Uint128  `protobuf:"bytes,1,opt,name=left,proto3,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"left"`
	Right                *github_com_gogo_protobuf_test_custom.Uint128 `protobuf:"bytes,2,opt,name=right,proto3,customtype=github.com/gogo/protobuf/test/custom.Uint128" json:"right,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                      `json:"-"`
	XXX_unrecognized     []byte                                        `json:"-"`
	XXX_sizecache        int32                                         `json:"-"`
}

func (m *Uint128Pair) Reset()      { *m = Uint128Pair{} }
func (*Uint128Pair) ProtoMessage() {}
func (*Uint128Pair) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{6}
}
func (m *Uint128Pair) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Uint128Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Uint128Pair.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Uint128Pair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uint128Pair.Merge(m, src)
}
func (m *Uint128Pair) XXX_Size() int {
	return m.Size()
}
func (m *Uint128Pair) XXX_DiscardUnknown() {
	xxx_messageInfo_Uint128Pair.DiscardUnknown(m)
}

var xxx_messageInfo_Uint128Pair proto.InternalMessageInfo

type ContainsNestedMap struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ContainsNestedMap) Reset()      { *m = ContainsNestedMap{} }
func (*ContainsNestedMap) ProtoMessage() {}
func (*ContainsNestedMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{7}
}
func (m *ContainsNestedMap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContainsNestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContainsNestedMap.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ContainsNestedMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainsNestedMap.Merge(m, src)
}
func (m *ContainsNestedMap) XXX_Size() int {
	return m.Size()
}
func (m *ContainsNestedMap) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainsNestedMap.DiscardUnknown(m)
}

var xxx_messageInfo_ContainsNestedMap proto.InternalMessageInfo

type ContainsNestedMap_NestedMap struct {
	NestedMapField       map[string]float64 `protobuf:"bytes,1,rep,name=NestedMapField,proto3" json:"NestedMapField,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *ContainsNestedMap_NestedMap) Reset()      { *m = ContainsNestedMap_NestedMap{} }
func (*ContainsNestedMap_NestedMap) ProtoMessage() {}
func (*ContainsNestedMap_NestedMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{7, 0}
}
func (m *ContainsNestedMap_NestedMap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ContainsNestedMap_NestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ContainsNestedMap_NestedMap.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ContainsNestedMap_NestedMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainsNestedMap_NestedMap.Merge(m, src)
}
func (m *ContainsNestedMap_NestedMap) XXX_Size() int {
	return m.Size()
}
func (m *ContainsNestedMap_NestedMap) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainsNestedMap_NestedMap.DiscardUnknown(m)
}

var xxx_messageInfo_ContainsNestedMap_NestedMap proto.InternalMessageInfo

type NotPacked struct {
	Key                  []uint64 `protobuf:"varint,5,rep,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NotPacked) Reset()      { *m = NotPacked{} }
func (*NotPacked) ProtoMessage() {}
func (*NotPacked) Descriptor() ([]byte, []int) {
	return fileDescriptor_198d1a76dbed8ec1, []int{8}
}
func (m *NotPacked) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NotPacked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NotPacked.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *NotPacked) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NotPacked.Merge(m, src)
}
func (m *NotPacked) XXX_Size() int {
	return m.Size()
}
func (m *NotPacked) XXX_DiscardUnknown() {
	xxx_messageInfo_NotPacked.DiscardUnknown(m)
}

var xxx_messageInfo_NotPacked proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("theproto3.MapEnum", MapEnum_name, MapEnum_value)
	proto.RegisterEnum("theproto3.Message_Humour", Message_Humour_name, Message_Humour_value)
	proto.RegisterType((*Message)(nil), "theproto3.Message")
	proto.RegisterMapType((map[int64]*both.NinOptEnum)(nil), "theproto3.Message.Proto2ValueEntry")
	proto.RegisterMapType((map[int64]*Nested)(nil), "theproto3.Message.TerrainEntry")
	proto.RegisterType((*Nested)(nil), "theproto3.Nested")
	proto.RegisterType((*AllMaps)(nil), "theproto3.AllMaps")
	proto.RegisterMapType((map[bool]bool)(nil), "theproto3.AllMaps.BoolMapEntry")
	proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMaps.Fixed32MapEntry")
	proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMaps.Fixed64MapEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Int32MapEntry")
	proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Int64MapEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Sfixed32MapEntry")
	proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Sfixed64MapEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMaps.Sint32MapEntry")
	proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMaps.Sint64MapEntry")
	proto.RegisterMapType((map[string]string)(nil), "theproto3.AllMaps.StringMapEntry")
	proto.RegisterMapType((map[string][]byte)(nil), "theproto3.AllMaps.StringToBytesMapEntry")
	proto.RegisterMapType((map[string]float64)(nil), "theproto3.AllMaps.StringToDoubleMapEntry")
	proto.RegisterMapType((map[string]MapEnum)(nil), "theproto3.AllMaps.StringToEnumMapEntry")
	proto.RegisterMapType((map[string]float32)(nil), "theproto3.AllMaps.StringToFloatMapEntry")
	proto.RegisterMapType((map[string]*FloatingPoint)(nil), "theproto3.AllMaps.StringToMsgMapEntry")
	proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMaps.Uint32MapEntry")
	proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMaps.Uint64MapEntry")
	proto.RegisterType((*AllMapsOrdered)(nil), "theproto3.AllMapsOrdered")
	proto.RegisterMapType((map[bool]bool)(nil), "theproto3.AllMapsOrdered.BoolMapEntry")
	proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMapsOrdered.Fixed32MapEntry")
	proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMapsOrdered.Fixed64MapEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Int32MapEntry")
	proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Int64MapEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Sfixed32MapEntry")
	proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Sfixed64MapEntry")
	proto.RegisterMapType((map[int32]int32)(nil), "theproto3.AllMapsOrdered.Sint32MapEntry")
	proto.RegisterMapType((map[int64]int64)(nil), "theproto3.AllMapsOrdered.Sint64MapEntry")
	proto.RegisterMapType((map[string]string)(nil), "theproto3.AllMapsOrdered.StringMapEntry")
	proto.RegisterMapType((map[string][]byte)(nil), "theproto3.AllMapsOrdered.StringToBytesMapEntry")
	proto.RegisterMapType((map[string]float64)(nil), "theproto3.AllMapsOrdered.StringToDoubleMapEntry")
	proto.RegisterMapType((map[string]MapEnum)(nil), "theproto3.AllMapsOrdered.StringToEnumMapEntry")
	proto.RegisterMapType((map[string]float32)(nil), "theproto3.AllMapsOrdered.StringToFloatMapEntry")
	proto.RegisterMapType((map[string]*FloatingPoint)(nil), "theproto3.AllMapsOrdered.StringToMsgMapEntry")
	proto.RegisterMapType((map[uint32]uint32)(nil), "theproto3.AllMapsOrdered.Uint32MapEntry")
	proto.RegisterMapType((map[uint64]uint64)(nil), "theproto3.AllMapsOrdered.Uint64MapEntry")
	proto.RegisterType((*MessageWithMap)(nil), "theproto3.MessageWithMap")
	proto.RegisterMapType((map[bool][]byte)(nil), "theproto3.MessageWithMap.ByteMappingEntry")
	proto.RegisterMapType((map[int64]*FloatingPoint)(nil), "theproto3.MessageWithMap.MsgMappingEntry")
	proto.RegisterMapType((map[int32]string)(nil), "theproto3.MessageWithMap.NameMappingEntry")
	proto.RegisterType((*FloatingPoint)(nil), "theproto3.FloatingPoint")
	proto.RegisterType((*Uint128Pair)(nil), "theproto3.Uint128Pair")
	proto.RegisterType((*ContainsNestedMap)(nil), "theproto3.ContainsNestedMap")
	proto.RegisterType((*ContainsNestedMap_NestedMap)(nil), "theproto3.ContainsNestedMap.NestedMap")
	proto.RegisterMapType((map[string]float64)(nil), "theproto3.ContainsNestedMap.NestedMap.NestedMapFieldEntry")
	proto.RegisterType((*NotPacked)(nil), "theproto3.NotPacked")
}

func init() { proto.RegisterFile("combos/both/theproto3.proto", fileDescriptor_198d1a76dbed8ec1) }

var fileDescriptor_198d1a76dbed8ec1 = []byte{
	// 1602 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x99, 0xcf, 0x6f, 0xdb, 0x46,
	0x16, 0xc7, 0x35, 0xfa, 0xad, 0xa7, 0x1f, 0xa6, 0x27, 0xd9, 0x85, 0xd6, 0x8b, 0xa5, 0x65, 0x05,
	0x48, 0x94, 0x60, 0x23, 0x67, 0x9d, 0x64, 0x37, 0xeb, 0xa6, 0x4d, 0x2d, 0xc5, 0x42, 0xdc, 0xd8,
	0x8a, 0x2b, 0xd9, 0x71, 0x8b, 0x00, 0x35, 0x28, 0x9b, 0x96, 0x88, 0x48, 0xa4, 0x21, 0x8e, 0x82,
	0xfa, 0x96, 0x3f, 0xa3, 0xb7, 0xa2, 0xb7, 0x1e, 0x8b, 0x1c, 0x8a, 0x1e, 0xdb, 0x9b, 0x8f, 0x01,
	0x7a, 0x29, 0x7a, 0x08, 0x62, 0xf5, 0x92, 0x63, 0x8e, 0x39, 0x16, 0x33, 0x43, 0x49, 0x23, 0x72,
	0x28, 0x36, 0xbd, 0xf4, 0xe2, 0x93, 0x38, 0xcf, 0xef, 0xfb, 0x99, 0xc7, 0xe1, 0xcc, 0xe3, 0x17,
	0x34, 0xfc, 0xf3, 0xc0, 0xea, 0xb5, 0x2c, 0x7b, 0xb9, 0x65, 0x91, 0xce, 0x32, 0xe9, 0xe8, 0xc7,
	0x7d, 0x8b, 0x58, 0x37, 0xcb, 0xec, 0x07, 0xa7, 0xc6, 0x81, 0x85, 0xeb, 0x6d, 0x83, 0x74, 0x06,
	0xad, 0xf2, 0x81, 0xd5, 0x5b, 0x6e, 0x5b, 0x6d, 0x6b, 0x99, 0xc5, 0x5b, 0x83, 0x23, 0x36, 0x62,
	0x03, 0x76, 0xc5, 0x95, 0x0b, 0xff, 0xf3, 0x4d, 0x27, 0xba, 0x4d, 0x96, 0x5d, 0x93, 0xd2, 0x18,
	0x17, 0x16, 0x7f, 0x8a, 0x41, 0x62, 0x4b, 0xb7, 0x6d, 0xad, 0xad, 0x63, 0x0c, 0x51, 0x53, 0xeb,
	0xe9, 0x79, 0x54, 0x40, 0xa5, 0x54, 0x83, 0x5d, 0xe3, 0xdb, 0x90, 0xec, 0x18, 0x5d, 0xad, 0x6f,
	0x90, 0x93, 0x7c, 0xb8, 0x80, 0x4a, 0xb9, 0x95, 0x7f, 0x94, 0x27, 0x65, 0x3b, 0xca, 0xf2, 0x83,
	0x41, 0xcf, 0x1a, 0xf4, 0x1b, 0xe3, 0x54, 0x5c, 0x80, 0x4c, 0x47, 0x37, 0xda, 0x1d, 0xb2, 0x6f,
	0x98, 0xfb, 0x07, 0xbd, 0x7c, 0xa4, 0x80, 0x4a, 0xd9, 0x06, 0xf0, 0xd8, 0x86, 0x59, 0xed, 0xd1,
	0xc9, 0x0e, 0x35, 0xa2, 0xe5, 0xa3, 0x05, 0x54, 0xca, 0x34, 0xd8, 0x35, 0x5e, 0x82, 0x4c, 0x5f,
	0xb7, 0x07, 0x5d, 0xb2, 0x7f, 0x60, 0x0d, 0x4c, 0x92, 0x4f, 0x14, 0x50, 0x29, 0xd2, 0x48, 0xf3,
	0x58, 0x95, 0x86, 0xf0, 0x25, 0xc8, 0x92, 0xfe, 0x40, 0xdf, 0xb7, 0x0f, 0x2c, 0x62, 0xf7, 0x34,
	0x33, 0x9f, 0x2c, 0xa0, 0x52, 0xb2, 0x91, 0xa1, 0xc1, 0xa6, 0x13, 0xc3, 0x17, 0x21, 0x66, 0x1f,
	0x58, 0x7d, 0x3d, 0x9f, 0x2a, 0xa0, 0x52, 0xb8, 0xc1, 0x07, 0x58, 0x81, 0xc8, 0x53, 0xfd, 0x24,
	0x1f, 0x2b, 0x44, 0x4a, 0xd1, 0x06, 0xbd, 0xc4, 0x57, 0x21, 0x6e, 0xea, 0x36, 0xd1, 0x0f, 0xf3,
	0xf1, 0x02, 0x2a, 0xa5, 0x57, 0xe6, 0x85, 0x5b, 0xab, 0xb3, 0x3f, 0x34, 0x9c, 0x04, 0xfc, 0x7f,
	0x48, 0x10, 0xbd, 0xdf, 0xd7, 0x0c, 0x33, 0x0f, 0x85, 0x48, 0x29, 0xbd, 0xb2, 0x28, 0x59, 0x86,
	0x1d, 0x9e, 0xb1, 0x6e, 0x92, 0xfe, 0x49, 0x63, 0x94, 0x8f, 0x6f, 0x43, 0x86, 0xe5, 0xad, 0xec,
	0x1f, 0x19, 0x7a, 0xf7, 0x30, 0x9f, 0x66, 0x73, 0xe1, 0x32, 0x7b, 0x0a, 0x75, 0xc3, 0x7c, 0x74,
	0x4c, 0xea, 0x1a, 0x31, 0x9e, 0xe9, 0x8d, 0x34, 0xcf, 0xab, 0xd1, 0x34, 0x5c, 0x1b, 0xcb, 0x9e,
	0x69, 0xdd, 0x81, 0x9e, 0xcf, 0xb2, 0x69, 0x2f, 0x49, 0xa6, 0xdd, 0x66, 0x69, 0x8f, 0x69, 0x16,
	0x9f, 0xda, 0xe1, 0xb0, 0xc8, 0xc2, 0x16, 0x64, 0xc4, 0xba, 0x46, 0xcb, 0x80, 0xd8, 0xda, 0xb2,
	0x65, 0xb8, 0x02, 0x31, 0x3e, 0x45, 0xd8, 0x6f, 0x15, 0xf8, 0xdf, 0x57, 0xc3, 0x77, 0xd0, 0xc2,
	0x36, 0x28, 0xee, 0xf9, 0x24, 0xc8, 0xcb, 0xd3, 0x48, 0x45, 0xbc, 0xd9, 0x75, 0x73, 0xd0, 0x13,
	0x88, 0xc5, 0x7b, 0x10, 0xe7, 0xfb, 0x07, 0xa7, 0x21, 0xb1, 0x5b, 0x7f, 0x58, 0x7f, 0xb4, 0x57,
	0x57, 0x42, 0x38, 0x09, 0xd1, 0xed, 0xdd, 0x7a, 0x53, 0x41, 0x38, 0x0b, 0xa9, 0xe6, 0xe6, 0xda,
	0x76, 0x73, 0x67, 0xa3, 0xfa, 0x50, 0x09, 0xe3, 0x39, 0x48, 0x57, 0x36, 0x36, 0x37, 0xf7, 0x2b,
	0x6b, 0x1b, 0x9b, 0xeb, 0x9f, 0x2b, 0x91, 0xa2, 0x0a, 0x71, 0x5e, 0x27, 0x7d, 0xf0, 0xad, 0x81,
	0x69, 0x9e, 0x38, 0x5b, 0x98, 0x0f, 0x8a, 0x2f, 0x30, 0x24, 0xd6, 0xba, 0xdd, 0x2d, 0xed, 0xd8,
	0xc6, 0x7b, 0x30, 0xdf, 0x24, 0x7d, 0xc3, 0x6c, 0xef, 0x58, 0xf7, 0xad, 0x41, 0xab, 0xab, 0x6f,
	0x69, 0xc7, 0x79, 0xc4, 0x96, 0xf6, 0xaa, 0x70, 0xdf, 0x4e, 0x7a, 0xd9, 0x93, 0xcb, 0x17, 0xd8,
	0xcb, 0xc0, 0x3b, 0xa0, 0x8c, 0x82, 0xb5, 0xae, 0xa5, 0x11, 0xca, 0x0d, 0x33, 0x6e, 0x69, 0x06,
	0x77, 0x94, 0xca, 0xb1, 0x1e, 0x02, 0xbe, 0x0b, 0xc9, 0x0d, 0x93, 0xdc, 0x5c, 0xa1, 0xb4, 0x08,
	0xa3, 0x15, 0x24, 0xb4, 0x51, 0x0a, 0xa7, 0x8c, 0x15, 0x8e, 0xfa, 0xbf, 0xb7, 0xa8, 0x3a, 0x3a,
	0x4b, 0xcd, 0x52, 0x26, 0x6a, 0x36, 0xc4, 0xf7, 0x20, 0xb5, 0x6b, 0x8c, 0x26, 0x8f, 0x31, 0xf9,
	0x92, 0x44, 0x3e, 0xce, 0xe1, 0xfa, 0x89, 0x66, 0x04, 0xe0, 0xf3, 0xc7, 0x67, 0x02, 0x84, 0x02,
	0x26, 0x1a, 0x0a, 0x68, 0x8e, 0x2b, 0x48, 0xf8, 0x02, 0x9a, 0xae, 0x0a, 0x9a, 0x62, 0x05, 0xcd,
	0x71, 0x05, 0xc9, 0x99, 0x00, 0xb1, 0x82, 0xf1, 0x18, 0x57, 0x00, 0x6a, 0xc6, 0x97, 0xfa, 0x21,
	0x2f, 0x21, 0xc5, 0x08, 0x45, 0x09, 0x61, 0x92, 0xc4, 0x11, 0x82, 0x0a, 0xaf, 0x43, 0xba, 0x79,
	0x34, 0x81, 0x80, 0xe7, 0x1c, 0x8f, 0xcb, 0x38, 0x72, 0x51, 0x44, 0xdd, 0xb8, 0x14, 0x7e, 0x33,
	0xe9, 0xd9, 0xa5, 0x08, 0x77, 0x23, 0xa8, 0x26, 0xa5, 0x70, 0x48, 0x26, 0xa0, 0x14, 0x81, 0x22,
	0xea, 0x68, 0x33, 0xac, 0x58, 0x16, 0xcd, 0x74, 0xba, 0xd2, 0xa2, 0x04, 0xe1, 0x64, 0x38, 0xcd,
	0xd0, 0x19, 0xb1, 0x27, 0xc2, 0x36, 0x39, 0x15, 0xe7, 0xfc, 0x9f, 0xc8, 0x28, 0x67, 0xf4, 0x44,
	0x46, 0x63, 0xf1, 0x9c, 0x55, 0x4e, 0x88, 0x6e, 0x53, 0xce, 0x5c, 0xe0, 0x39, 0x1b, 0xa5, 0xba,
	0xce, 0xd9, 0x28, 0x8c, 0x3f, 0x85, 0xb9, 0x51, 0x8c, 0xb6, 0x27, 0x0a, 0x55, 0x18, 0xf4, 0xca,
	0x0c, 0xa8, 0x93, 0xc9, 0x99, 0x6e, 0x3d, 0xae, 0x43, 0x6e, 0x14, 0xda, 0xb2, 0xd9, 0xed, 0xce,
	0x33, 0xe2, 0xe5, 0x19, 0x44, 0x9e, 0xc8, 0x81, 0x2e, 0xf5, 0xc2, 0x7d, 0xf8, 0xbb, 0xbc, 0x1b,
	0x89, 0xed, 0x37, 0xc5, 0xdb, 0xef, 0x45, 0xb1, 0xfd, 0x22, 0xb1, 0x7d, 0x57, 0xe1, 0x6f, 0xd2,
	0xde, 0x13, 0x04, 0x09, 0x8b, 0x90, 0x0f, 0x20, 0x3b, 0xd5, 0x72, 0x44, 0x71, 0x4c, 0x22, 0x8e,
	0x79, 0xc5, 0x93, 0xad, 0x25, 0x79, 0x7b, 0x4c, 0x89, 0x23, 0xa2, 0xf8, 0x2e, 0xe4, 0xa6, 0xfb,
	0x8d, 0xa8, 0xce, 0x4a, 0xd4, 0x59, 0x89, 0x5a, 0x3e, 0x77, 0x54, 0xa2, 0x8e, 0xba, 0xd4, 0x4d,
	0xdf, 0xb9, 0xe7, 0x25, 0xea, 0x79, 0x89, 0x5a, 0x3e, 0x37, 0x96, 0xa8, 0xb1, 0xa8, 0xfe, 0x10,
	0xe6, 0x5c, 0x2d, 0x46, 0x94, 0x27, 0x24, 0xf2, 0x84, 0x28, 0xff, 0x08, 0x14, 0x77, 0x73, 0x11,
	0xf5, 0x73, 0x12, 0xfd, 0x9c, 0x6c, 0x7a, 0x79, 0xf5, 0x71, 0x89, 0x3c, 0x2e, 0x9d, 0x5e, 0xae,
	0x57, 0x24, 0x7a, 0x45, 0xd4, 0xaf, 0x42, 0x46, 0xec, 0x26, 0xa2, 0x36, 0x29, 0xd1, 0x26, 0xdd,
	0xeb, 0x3e, 0xd5, 0x4c, 0x82, 0x76, 0x7a, 0xca, 0xe7, 0xb8, 0x4c, 0xb5, 0x90, 0x20, 0x48, 0x46,
	0x84, 0x3c, 0x86, 0x8b, 0xb2, 0x96, 0x21, 0x61, 0x94, 0x44, 0x46, 0x8e, 0x7a, 0xc4, 0x89, 0xd9,
	0xa3, 0xaa, 0x29, 0xe3, 0xb4, 0xf0, 0x04, 0x2e, 0x48, 0x1a, 0x87, 0x04, 0x5b, 0x9e, 0x76, 0x63,
	0x79, 0x01, 0xcb, 0x9a, 0x80, 0x61, 0xb6, 0xb7, 0x2d, 0xc3, 0x24, 0xa2, 0x2b, 0xfb, 0xfe, 0x02,
	0xe4, 0x9c, 0xf6, 0xf4, 0xa8, 0x7f, 0xa8, 0xf7, 0xf5, 0x43, 0xfc, 0x85, 0xbf, 0x77, 0xba, 0xe1,
	0x6d, 0x6a, 0x8e, 0xea, 0x3d, 0x2c, 0xd4, 0x13, 0x5f, 0x0b, 0xb5, 0x1c, 0x8c, 0x0f, 0x72, 0x52,
	0x55, 0x8f, 0x93, 0xba, 0xe2, 0x0f, 0xf5, 0x33, 0x54, 0x55, 0x8f, 0xa1, 0x9a, 0x0d, 0x91, 0xfa,
	0xaa, 0x9a, 0xd7, 0x57, 0x95, 0xfc, 0x29, 0xfe, 0xf6, 0xaa, 0xe6, 0xb5, 0x57, 0x01, 0x1c, 0xb9,
	0xcb, 0xaa, 0x79, 0x5d, 0xd6, 0x0c, 0x8e, 0xbf, 0xd9, 0xaa, 0x79, 0xcd, 0x56, 0x00, 0x47, 0xee,
	0xb9, 0x36, 0x24, 0x9e, 0xeb, 0xaa, 0x3f, 0x68, 0x96, 0xf5, 0xda, 0x94, 0x59, 0xaf, 0x6b, 0x33,
	0x8a, 0x9a, 0xe9, 0xc0, 0x36, 0x24, 0x0e, 0x2c, 0xa8, 0x30, 0x1f, 0x23, 0xb6, 0x29, 0x33, 0x62,
	0x81, 0x85, 0xf9, 0xf9, 0xb1, 0x8f, 0xdd, 0x7e, 0xec, 0xb2, 0x3f, 0x49, 0x6e, 0xcb, 0x6a, 0x5e,
	0x5b, 0x56, 0x0a, 0x3a, 0x73, 0x32, 0x77, 0xf6, 0xc4, 0xd7, 0x9d, 0xfd, 0x81, 0x23, 0x1c, 0x64,
	0xd2, 0x3e, 0xf3, 0x33, 0x69, 0xe5, 0x60, 0xf6, 0x6c, 0xaf, 0xb6, 0xeb, 0xe3, 0xd5, 0xae, 0x07,
	0x83, 0xcf, 0x2d, 0xdb, 0xb9, 0x65, 0x3b, 0xb7, 0x6c, 0xe7, 0x96, 0xed, 0xaf, 0xb7, 0x6c, 0xab,
	0xd1, 0xaf, 0xbe, 0x59, 0x44, 0xc5, 0x9f, 0x23, 0x90, 0x73, 0xbe, 0x0c, 0xee, 0x19, 0xa4, 0x43,
	0xdb, 0xdb, 0x16, 0x64, 0x4c, 0xad, 0xa7, 0xef, 0xf7, 0xb4, 0xe3, 0x63, 0xc3, 0x6c, 0x3b, 0x9e,
	0xed, 0x9a, 0xf7, 0x53, 0xa2, 0x23, 0x28, 0xd7, 0xb5, 0x1e, 0xed, 0x55, 0x34, 0xd9, 0x79, 0xdd,
	0x98, 0x93, 0x08, 0xfe, 0x04, 0xd2, 0x3d, 0xbb, 0x3d, 0xa6, 0x85, 0x3d, 0x2f, 0x42, 0x17, 0x8d,
	0xdf, 0xe9, 0x04, 0x06, 0xbd, 0x71, 0x80, 0x96, 0xd6, 0x3a, 0x21, 0x93, 0xd2, 0x22, 0x41, 0xa5,
	0xd1, 0x67, 0x3a, 0x5d, 0x5a, 0x6b, 0x12, 0xa1, 0xdb, 0xd6, 0x5d, 0x7b, 0x50, 0xa7, 0x9b, 0xda,
	0x3c, 0x7b, 0x30, 0xe7, 0xaa, 0x56, 0x72, 0xe6, 0xff, 0xc4, 0xb3, 0xa1, 0x85, 0xb9, 0x2b, 0x0f,
	0x3a, 0x13, 0xe2, 0x86, 0x2c, 0xfe, 0x0b, 0xb2, 0x53, 0x6c, 0x9c, 0x01, 0x74, 0xc4, 0xa4, 0xa8,
	0x81, 0x8e, 0x8a, 0x5f, 0x23, 0x48, 0xd3, 0x3e, 0xf9, 0x9f, 0x95, 0x3b, 0xdb, 0x9a, 0xd1, 0xc7,
	0x0f, 0x20, 0xda, 0xd5, 0x8f, 0x08, 0x4b, 0xc8, 0x54, 0x6e, 0x9d, 0xbe, 0x5a, 0x0c, 0xfd, 0xfa,
	0x6a, 0xf1, 0xdf, 0x01, 0xff, 0x25, 0x18, 0xd8, 0xc4, 0xea, 0x95, 0x1d, 0x4e, 0x83, 0x11, 0x70,
	0x0d, 0x62, 0x7d, 0xa3, 0xdd, 0x21, 0xbc, 0xa4, 0xca, 0x8d, 0xf7, 0xc6, 0x70, 0x79, 0xf1, 0x14,
	0xc1, 0x7c, 0xd5, 0x32, 0x89, 0x66, 0x98, 0x36, 0xff, 0x5a, 0x4b, 0xdf, 0x90, 0x2f, 0x10, 0xa4,
	0xc6, 0x23, 0xdc, 0x82, 0xdc, 0x78, 0xc0, 0x3e, 0x82, 0x3b, 0x3b, 0x75, 0x55, 0x58, 0x61, 0x0f,
	0xa3, 0x2c, 0xb9, 0x62, 0x62, 0xe7, 0x9d, 0x3c, 0x1d, 0x5c, 0x58, 0x83, 0x0b, 0x92, 0xb4, 0xf7,
	0x79, 0x21, 0x17, 0x97, 0x20, 0x55, 0xb7, 0xc8, 0xb6, 0x76, 0xf0, 0x94, 0x7d, 0x72, 0x9e, 0xfc,
	0x57, 0xa1, 0x12, 0x56, 0x42, 0x4c, 0x7c, 0x6d, 0x09, 0x12, 0xce, 0xe9, 0xc7, 0x71, 0x08, 0x6f,
	0xad, 0x29, 0x21, 0xf6, 0x5b, 0x51, 0x10, 0xfb, 0xad, 0x2a, 0xe1, 0xca, 0xe6, 0xe9, 0x99, 0x1a,
	0x7a, 0x79, 0xa6, 0x86, 0x7e, 0x39, 0x53, 0x43, 0xaf, 0xcf, 0x54, 0xf4, 0xe6, 0x4c, 0x45, 0x6f,
	0xcf, 0x54, 0xf4, 0xee, 0x4c, 0x45, 0xcf, 0x87, 0x2a, 0xfa, 0x76, 0xa8, 0xa2, 0xef, 0x86, 0x2a,
	0xfa, 0x61, 0xa8, 0xa2, 0x1f, 0x87, 0x2a, 0x3a, 0x1d, 0xaa, 0xe8, 0xe5, 0x50, 0x45, 0xaf, 0x87,
	0x2a, 0x7a, 0x33, 0x54, 0x43, 0x6f, 0x87, 0x2a, 0x7a, 0x37, 0x54, 0x43, 0xcf, 0x7f, 0x53, 0x43,
	0xad, 0x38, 0x5f, 0x9e, 0xdf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xea, 0x4a, 0x44, 0x79, 0x60, 0x1a,
	0x00, 0x00,
}

func (this *Message) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *Nested) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *AllMaps) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *AllMapsOrdered) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *MessageWithMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *FloatingPoint) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *Uint128Pair) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *ContainsNestedMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *ContainsNestedMap_NestedMap) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func (this *NotPacked) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	return Theproto3Description()
}
func Theproto3Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) {
	d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{}
	var gzipped = []byte{
		// 8086 bytes of a gzipped FileDescriptorSet
		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x5b, 0x70, 0x23, 0xd7,
		0x99, 0xde, 0x34, 0x1a, 0x20, 0x81, 0x1f, 0x20, 0xd9, 0x6c, 0xce, 0x50, 0x10, 0x35, 0x22, 0x67,
		0xa0, 0xd1, 0x88, 0xa2, 0x25, 0x0e, 0x87, 0xc3, 0xb9, 0x61, 0x2c, 0x69, 0x01, 0x10, 0x1c, 0x71,
		0x4c, 0x82, 0x74, 0x93, 0xb4, 0x34, 0x56, 0x12, 0x54, 0x13, 0x68, 0x92, 0x90, 0x80, 0x6e, 0x2c,
		0xba, 0x21, 0x89, 0xaa, 0x54, 0x4a, 0x59, 0x27, 0x1b, 0x6f, 0xee, 0xc9, 0x26, 0x15, 0xaf, 0xe3,
		0x8b, 0xbc, 0x5b, 0xbb, 0xf6, 0x6e, 0x6e, 0x5e, 0x67, 0xe3, 0xec, 0x3a, 0xa9, 0xac, 0xf2, 0xe0,
		0x64, 0xf2, 0x92, 0xf2, 0x26, 0x2f, 0x29, 0x57, 0x4a, 0x65, 0x8d, 0x9d, 0x8a, 0x93, 0x38, 0x89,
		0xb3, 0x51, 0x55, 0x5c, 0xe5, 0x7d, 0x48, 0x9d, 0x5b, 0xf7, 0x39, 0x07, 0x0d, 0x34, 0x38, 0x92,
		0x6c, 0x3f, 0xf8, 0x65, 0x06, 0x7d, 0xce, 0xff, 0x7d, 0xfd, 0xf7, 0x7f, 0x39, 0xe7, 0xef, 0x73,
		0x0e, 0x40, 0xb8, 0x97, 0x87, 0x73, 0x87, 0x8e, 0x73, 0xd8, 0xb4, 0x2e, 0xb5, 0x3b, 0x8e, 0xe7,
		0xec, 0x77, 0x0f, 0x2e, 0xd5, 0x2d, 0xb7, 0xd6, 0x69, 0xb4, 0x3d, 0xa7, 0xb3, 0x88, 0xdb, 0xf4,
		0x09, 0x22, 0xb1, 0xc8, 0x24, 0x72, 0x9b, 0x30, 0xb9, 0xd6, 0x68, 0x5a, 0xab, 0xbe, 0xe0, 0x8e,
		0xe5, 0xe9, 0x37, 0x20, 0x7e, 0xd0, 0x68, 0x5a, 0x59, 0xe5, 0x9c, 0x3a, 0x9f, 0x5e, 0xbe, 0xb0,
		0x28, 0x81, 0x16, 0x45, 0xc4, 0x36, 0x6a, 0x36, 0x30, 0x22, 0xf7, 0xbd, 0x38, 0x4c, 0x85, 0xf4,
		0xea, 0x3a, 0xc4, 0x6d, 0xb3, 0x85, 0x18, 0x95, 0xf9, 0x94, 0x81, 0x3f, 0xeb, 0x59, 0x18, 0x6d,
		0x9b, 0xb5, 0x57, 0xcc, 0x43, 0x2b, 0x1b, 0xc3, 0xcd, 0xec, 0x52, 0x9f, 0x05, 0xa8, 0x5b, 0x6d,
		0xcb, 0xae, 0x5b, 0x76, 0xed, 0x38, 0xab, 0x9e, 0x53, 0xe7, 0x53, 0x06, 0xd7, 0xa2, 0x7f, 0x04,
		0x26, 0xdb, 0xdd, 0xfd, 0x66, 0xa3, 0x56, 0xe5, 0xc4, 0xe0, 0x9c, 0x3a, 0x9f, 0x30, 0x34, 0xd2,
		0xb1, 0x1a, 0x08, 0x3f, 0x01, 0x13, 0xaf, 0x59, 0xe6, 0x2b, 0xbc, 0x68, 0x1a, 0x8b, 0x8e, 0xa3,
		0x66, 0x4e, 0xb0, 0x04, 0x99, 0x96, 0xe5, 0xba, 0xe6, 0xa1, 0x55, 0xf5, 0x8e, 0xdb, 0x56, 0x36,
		0x8e, 0x9f, 0xfe, 0x5c, 0xcf, 0xd3, 0xcb, 0x4f, 0x9e, 0xa6, 0xa8, 0xdd, 0xe3, 0xb6, 0xa5, 0x17,
		0x20, 0x65, 0xd9, 0xdd, 0x16, 0x61, 0x48, 0xf4, 0xb1, 0x5f, 0xd9, 0xee, 0xb6, 0x64, 0x96, 0x24,
		0x82, 0x51, 0x8a, 0x51, 0xd7, 0xea, 0xbc, 0xda, 0xa8, 0x59, 0xd9, 0x11, 0x4c, 0xf0, 0x44, 0x0f,
		0xc1, 0x0e, 0xe9, 0x97, 0x39, 0x18, 0x4e, 0x2f, 0x41, 0xca, 0x7a, 0xdd, 0xb3, 0x6c, 0xb7, 0xe1,
		0xd8, 0xd9, 0x51, 0x4c, 0xf2, 0x78, 0x88, 0x17, 0xad, 0x66, 0x5d, 0xa6, 0x08, 0x70, 0xfa, 0x35,
		0x18, 0x75, 0xda, 0x5e, 0xc3, 0xb1, 0xdd, 0x6c, 0xf2, 0x9c, 0x32, 0x9f, 0x5e, 0x3e, 0x1b, 0x1a,
		0x08, 0x5b, 0x44, 0xc6, 0x60, 0xc2, 0xfa, 0x3a, 0x68, 0xae, 0xd3, 0xed, 0xd4, 0xac, 0x6a, 0xcd,
		0xa9, 0x5b, 0xd5, 0x86, 0x7d, 0xe0, 0x64, 0x53, 0x98, 0x60, 0xae, 0xf7, 0x41, 0xb0, 0x60, 0xc9,
		0xa9, 0x5b, 0xeb, 0xf6, 0x81, 0x63, 0x8c, 0xbb, 0xc2, 0xb5, 0x3e, 0x0d, 0x23, 0xee, 0xb1, 0xed,
		0x99, 0xaf, 0x67, 0x33, 0x38, 0x42, 0xe8, 0x55, 0xee, 0x0f, 0x46, 0x60, 0x62, 0x98, 0x10, 0xbb,
		0x05, 0x89, 0x03, 0xf4, 0x94, 0xd9, 0xd8, 0x49, 0x6c, 0x40, 0x30, 0xa2, 0x11, 0x47, 0x1e, 0xd0,
		0x88, 0x05, 0x48, 0xdb, 0x96, 0xeb, 0x59, 0x75, 0x12, 0x11, 0xea, 0x90, 0x31, 0x05, 0x04, 0xd4,
		0x1b, 0x52, 0xf1, 0x07, 0x0a, 0xa9, 0x17, 0x61, 0xc2, 0x57, 0xa9, 0xda, 0x31, 0xed, 0x43, 0x16,
		0x9b, 0x97, 0xa2, 0x34, 0x59, 0x2c, 0x33, 0x9c, 0x81, 0x60, 0xc6, 0xb8, 0x25, 0x5c, 0xeb, 0xab,
		0x00, 0x8e, 0x6d, 0x39, 0x07, 0xd5, 0xba, 0x55, 0x6b, 0x66, 0x93, 0x7d, 0xac, 0xb4, 0x85, 0x44,
		0x7a, 0xac, 0xe4, 0x90, 0xd6, 0x5a, 0x53, 0xbf, 0x19, 0x84, 0xda, 0x68, 0x9f, 0x48, 0xd9, 0x24,
		0x49, 0xd6, 0x13, 0x6d, 0x7b, 0x30, 0xde, 0xb1, 0x50, 0xdc, 0x5b, 0x75, 0xfa, 0x64, 0x29, 0xac,
		0xc4, 0x62, 0xe4, 0x93, 0x19, 0x14, 0x46, 0x1e, 0x6c, 0xac, 0xc3, 0x5f, 0xea, 0x8f, 0x81, 0xdf,
		0x50, 0xc5, 0x61, 0x05, 0x78, 0x14, 0xca, 0xb0, 0xc6, 0x8a, 0xd9, 0xb2, 0x66, 0xde, 0x80, 0x71,
		0xd1, 0x3c, 0xfa, 0x69, 0x48, 0xb8, 0x9e, 0xd9, 0xf1, 0x70, 0x14, 0x26, 0x0c, 0x72, 0xa1, 0x6b,
		0xa0, 0x5a, 0x76, 0x1d, 0x8f, 0x72, 0x09, 0x03, 0x7d, 0xd4, 0x7f, 0x21, 0x78, 0x60, 0x15, 0x3f,
		0xf0, 0xc5, 0x5e, 0x8f, 0x0a, 0xcc, 0xf2, 0x73, 0xcf, 0x5c, 0x87, 0x31, 0xe1, 0x01, 0x86, 0xbd,
		0x75, 0xee, 0xcf, 0xc2, 0x99, 0x50, 0x6a, 0xfd, 0x45, 0x38, 0xdd, 0xb5, 0x1b, 0xb6, 0x67, 0x75,
		0xda, 0x1d, 0x0b, 0x45, 0x2c, 0xb9, 0x55, 0xf6, 0xbf, 0x8e, 0xf6, 0x89, 0xb9, 0x3d, 0x5e, 0x9a,
		0xb0, 0x18, 0x53, 0xdd, 0xde, 0xc6, 0x85, 0x54, 0xf2, 0xfb, 0xa3, 0xda, 0x9b, 0x6f, 0xbe, 0xf9,
		0x66, 0x2c, 0xf7, 0x99, 0x11, 0x38, 0x1d, 0x96, 0x33, 0xa1, 0xe9, 0x3b, 0x0d, 0x23, 0x76, 0xb7,
		0xb5, 0x6f, 0x75, 0xb0, 0x91, 0x12, 0x06, 0xbd, 0xd2, 0x0b, 0x90, 0x68, 0x9a, 0xfb, 0x56, 0x33,
		0x1b, 0x3f, 0xa7, 0xcc, 0x8f, 0x2f, 0x7f, 0x64, 0xa8, 0xac, 0x5c, 0xdc, 0x40, 0x10, 0x83, 0x20,
		0xf5, 0x67, 0x21, 0x4e, 0x87, 0x68, 0xc4, 0xb0, 0x30, 0x1c, 0x03, 0xca, 0x25, 0x03, 0xe3, 0xf4,
		0x47, 0x20, 0x85, 0xfe, 0x27, 0xb1, 0x31, 0x82, 0x75, 0x4e, 0xa2, 0x06, 0x14, 0x17, 0xfa, 0x0c,
		0x24, 0x71, 0x9a, 0xd4, 0x2d, 0x36, 0xb5, 0xf9, 0xd7, 0x28, 0xb0, 0xea, 0xd6, 0x81, 0xd9, 0x6d,
		0x7a, 0xd5, 0x57, 0xcd, 0x66, 0xd7, 0xc2, 0x01, 0x9f, 0x32, 0x32, 0xb4, 0xf1, 0x13, 0xa8, 0x4d,
		0x9f, 0x83, 0x34, 0xc9, 0xaa, 0x86, 0x5d, 0xb7, 0x5e, 0xc7, 0xa3, 0x67, 0xc2, 0x20, 0x89, 0xb6,
		0x8e, 0x5a, 0xd0, 0xed, 0x5f, 0x76, 0x1d, 0x9b, 0x85, 0x26, 0xbe, 0x05, 0x6a, 0xc0, 0xb7, 0xbf,
		0x2e, 0x0f, 0xdc, 0x8f, 0x86, 0x3f, 0x9e, 0x1c, 0x53, 0xb9, 0xaf, 0xc7, 0x20, 0x8e, 0xc7, 0x8b,
		0x09, 0x48, 0xef, 0xde, 0xdd, 0x2e, 0x57, 0x57, 0xb7, 0xf6, 0x8a, 0x1b, 0x65, 0x4d, 0xd1, 0xc7,
		0x01, 0x70, 0xc3, 0xda, 0xc6, 0x56, 0x61, 0x57, 0x8b, 0xf9, 0xd7, 0xeb, 0x95, 0xdd, 0x6b, 0x2b,
		0x9a, 0xea, 0x03, 0xf6, 0x48, 0x43, 0x9c, 0x17, 0xb8, 0xb2, 0xac, 0x25, 0x74, 0x0d, 0x32, 0x84,
		0x60, 0xfd, 0xc5, 0xf2, 0xea, 0xb5, 0x15, 0x6d, 0x44, 0x6c, 0xb9, 0xb2, 0xac, 0x8d, 0xea, 0x63,
		0x90, 0xc2, 0x2d, 0xc5, 0xad, 0xad, 0x0d, 0x2d, 0xe9, 0x73, 0xee, 0xec, 0x1a, 0xeb, 0x95, 0xdb,
		0x5a, 0xca, 0xe7, 0xbc, 0x6d, 0x6c, 0xed, 0x6d, 0x6b, 0xe0, 0x33, 0x6c, 0x96, 0x77, 0x76, 0x0a,
		0xb7, 0xcb, 0x5a, 0xda, 0x97, 0x28, 0xde, 0xdd, 0x2d, 0xef, 0x68, 0x19, 0x41, 0xad, 0x2b, 0xcb,
		0xda, 0x98, 0x7f, 0x8b, 0x72, 0x65, 0x6f, 0x53, 0x1b, 0xd7, 0x27, 0x61, 0x8c, 0xdc, 0x82, 0x29,
		0x31, 0x21, 0x35, 0x5d, 0x5b, 0xd1, 0xb4, 0x40, 0x11, 0xc2, 0x32, 0x29, 0x34, 0x5c, 0x5b, 0xd1,
		0xf4, 0x5c, 0x09, 0x12, 0x38, 0xba, 0x74, 0x1d, 0xc6, 0x37, 0x0a, 0xc5, 0xf2, 0x46, 0x75, 0x6b,
		0x7b, 0x77, 0x7d, 0xab, 0x52, 0xd8, 0xd0, 0x94, 0xa0, 0xcd, 0x28, 0x7f, 0x7c, 0x6f, 0xdd, 0x28,
		0xaf, 0x6a, 0x31, 0xbe, 0x6d, 0xbb, 0x5c, 0xd8, 0x2d, 0xaf, 0x6a, 0x6a, 0xae, 0x06, 0xa7, 0xc3,
		0xc6, 0xc9, 0xd0, 0xcc, 0xe0, 0x5c, 0x1c, 0xeb, 0xe3, 0x62, 0xcc, 0xd5, 0xe3, 0xe2, 0xef, 0xc6,
		0x60, 0x2a, 0x64, 0xae, 0x08, 0xbd, 0xc9, 0x73, 0x90, 0x20, 0x21, 0x4a, 0x66, 0xcf, 0x27, 0x43,
		0x27, 0x1d, 0x1c, 0xb0, 0x3d, 0x33, 0x28, 0xc6, 0xf1, 0x15, 0x84, 0xda, 0xa7, 0x82, 0x40, 0x14,
		0x3d, 0x63, 0xfa, 0x9f, 0xee, 0x19, 0xd3, 0xc9, 0xb4, 0x77, 0x6d, 0x98, 0x69, 0x0f, 0xb7, 0x9d,
		0x6c, 0x6c, 0x4f, 0x84, 0x8c, 0xed, 0xb7, 0x60, 0xb2, 0x87, 0x68, 0xe8, 0x31, 0xf6, 0x53, 0x0a,
		0x64, 0xfb, 0x19, 0x27, 0x62, 0xa4, 0x8b, 0x09, 0x23, 0xdd, 0x2d, 0xd9, 0x82, 0xe7, 0xfb, 0x3b,
		0xa1, 0xc7, 0xd7, 0x5f, 0x56, 0x60, 0x3a, 0xbc, 0x52, 0x0c, 0xd5, 0xe1, 0x59, 0x18, 0x69, 0x59,
		0xde, 0x91, 0xc3, 0xaa, 0xa5, 0x8b, 0x21, 0x73, 0x30, 0xea, 0x96, 0x9d, 0x4d, 0x51, 0xfc, 0x24,
		0xae, 0xf6, 0x2b, 0xf7, 0x88, 0x36, 0x3d, 0x9a, 0xfe, 0x4a, 0x0c, 0xce, 0x84, 0x92, 0x87, 0x2a,
		0xfa, 0x28, 0x40, 0xc3, 0x6e, 0x77, 0x3d, 0x52, 0x11, 0x91, 0x01, 0x36, 0x85, 0x5b, 0xf0, 0xe0,
		0x85, 0x06, 0xcf, 0xae, 0xe7, 0xf7, 0xab, 0xb8, 0x1f, 0x48, 0x13, 0x16, 0xb8, 0x11, 0x28, 0x1a,
		0xc7, 0x8a, 0xce, 0xf6, 0x79, 0xd2, 0x9e, 0xc0, 0x5c, 0x02, 0xad, 0xd6, 0x6c, 0x58, 0xb6, 0x57,
		0x75, 0xbd, 0x8e, 0x65, 0xb6, 0x1a, 0xf6, 0x21, 0x9e, 0x41, 0x92, 0xf9, 0xc4, 0x81, 0xd9, 0x74,
		0x2d, 0x63, 0x82, 0x74, 0xef, 0xb0, 0x5e, 0x84, 0xc0, 0x01, 0xd4, 0xe1, 0x10, 0x23, 0x02, 0x82,
		0x74, 0xfb, 0x88, 0xdc, 0x5f, 0x4d, 0x41, 0x9a, 0xab, 0xab, 0xf5, 0xf3, 0x90, 0x79, 0xd9, 0x7c,
		0xd5, 0xac, 0xb2, 0x77, 0x25, 0x62, 0x89, 0x34, 0x6a, 0xdb, 0xa6, 0xef, 0x4b, 0x4b, 0x70, 0x1a,
		0x8b, 0x38, 0x5d, 0xcf, 0xea, 0x54, 0x6b, 0x4d, 0xd3, 0x75, 0xb1, 0xd1, 0x92, 0x58, 0x54, 0x47,
		0x7d, 0x5b, 0xa8, 0xab, 0xc4, 0x7a, 0xf4, 0xab, 0x30, 0x85, 0x11, 0xad, 0x6e, 0xd3, 0x6b, 0xb4,
		0x9b, 0x56, 0x15, 0xbd, 0xbd, 0xb9, 0x78, 0x26, 0xf1, 0x35, 0x9b, 0x44, 0x12, 0x9b, 0x54, 0x00,
		0x69, 0xe4, 0xea, 0xab, 0xf0, 0x28, 0x86, 0x1d, 0x5a, 0xb6, 0xd5, 0x31, 0x3d, 0xab, 0x6a, 0xfd,
		0x62, 0xd7, 0x6c, 0xba, 0x55, 0xd3, 0xae, 0x57, 0x8f, 0x4c, 0xf7, 0x28, 0x7b, 0x1a, 0x11, 0x14,
		0x63, 0x59, 0xc5, 0x78, 0x18, 0x09, 0xde, 0xa6, 0x72, 0x65, 0x2c, 0x56, 0xb0, 0xeb, 0xcf, 0x9b,
		0xee, 0x91, 0x9e, 0x87, 0x69, 0xcc, 0xe2, 0x7a, 0x9d, 0x86, 0x7d, 0x58, 0xad, 0x1d, 0x59, 0xb5,
		0x57, 0xaa, 0x5d, 0xef, 0xe0, 0x46, 0xf6, 0x11, 0xfe, 0xfe, 0x58, 0xc3, 0x1d, 0x2c, 0x53, 0x42,
		0x22, 0x7b, 0xde, 0xc1, 0x0d, 0x7d, 0x07, 0x32, 0xc8, 0x19, 0xad, 0xc6, 0x1b, 0x56, 0xf5, 0xc0,
		0xe9, 0xe0, 0xa9, 0x71, 0x3c, 0x64, 0x68, 0xe2, 0x2c, 0xb8, 0xb8, 0x45, 0x01, 0x9b, 0x4e, 0xdd,
		0xca, 0x27, 0x76, 0xb6, 0xcb, 0xe5, 0x55, 0x23, 0xcd, 0x58, 0xd6, 0x9c, 0x0e, 0x0a, 0xa8, 0x43,
		0xc7, 0x37, 0x70, 0x9a, 0x04, 0xd4, 0xa1, 0xc3, 0xcc, 0x7b, 0x15, 0xa6, 0x6a, 0x35, 0xf2, 0xcc,
		0x8d, 0x5a, 0x95, 0xbe, 0x63, 0xb9, 0x59, 0x4d, 0x30, 0x56, 0xad, 0x76, 0x9b, 0x08, 0xd0, 0x18,
		0x77, 0xf5, 0x9b, 0x70, 0x26, 0x30, 0x16, 0x0f, 0x9c, 0xec, 0x79, 0x4a, 0x19, 0x7a, 0x15, 0xa6,
		0xda, 0xc7, 0xbd, 0x40, 0x5d, 0xb8, 0x63, 0xfb, 0x58, 0x86, 0x5d, 0x87, 0xd3, 0xed, 0xa3, 0x76,
		0x2f, 0x6e, 0x81, 0xc7, 0xe9, 0xed, 0xa3, 0xb6, 0x0c, 0x7c, 0x1c, 0xbf, 0x70, 0x77, 0xac, 0x9a,
		0xe9, 0x59, 0xf5, 0xec, 0x43, 0xbc, 0x38, 0xd7, 0xa1, 0x5f, 0x02, 0xad, 0x56, 0xab, 0x5a, 0xb6,
		0xb9, 0xdf, 0xb4, 0xaa, 0x66, 0xc7, 0xb2, 0x4d, 0x37, 0x3b, 0xc7, 0x0b, 0x8f, 0xd7, 0x6a, 0x65,
		0xdc, 0x5b, 0xc0, 0x9d, 0xfa, 0x02, 0x4c, 0x3a, 0xfb, 0x2f, 0xd7, 0x48, 0x48, 0x56, 0xdb, 0x1d,
		0xeb, 0xa0, 0xf1, 0x7a, 0xf6, 0x02, 0xb6, 0xef, 0x04, 0xea, 0xc0, 0x01, 0xb9, 0x8d, 0x9b, 0xf5,
		0x27, 0x41, 0xab, 0xb9, 0x47, 0x66, 0xa7, 0x8d, 0xc7, 0x64, 0xb7, 0x6d, 0xd6, 0xac, 0xec, 0xe3,
		0x44, 0x94, 0xb4, 0x57, 0x58, 0x33, 0x4a, 0x09, 0xf7, 0xb5, 0xc6, 0x81, 0xc7, 0x18, 0x9f, 0x20,
		0x29, 0x81, 0xdb, 0x28, 0xdb, 0x3c, 0x68, 0xc8, 0x14, 0xc2, 0x8d, 0xe7, 0xb1, 0xd8, 0x78, 0xfb,
		0xa8, 0xcd, 0xdf, 0xf7, 0x31, 0x18, 0x43, 0x92, 0xc1, 0x4d, 0x9f, 0x24, 0x05, 0x59, 0xfb, 0x88,
		0xbb, 0xe3, 0x0a, 0x4c, 0x23, 0xa1, 0x96, 0xe5, 0x99, 0x75, 0xd3, 0x33, 0x39, 0xe9, 0xa7, 0xb0,
		0x34, 0xb2, 0xfb, 0x26, 0xed, 0x14, 0xf4, 0xec, 0x74, 0xf7, 0x8f, 0xfd, 0xc8, 0x7a, 0x9a, 0xe8,
		0x89, 0xda, 0x58, 0x6c, 0x7d, 0x68, 0x45, 0x77, 0x2e, 0x0f, 0x19, 0x3e, 0xf0, 0xf5, 0x14, 0x90,
		0xd0, 0xd7, 0x14, 0x54, 0x05, 0x95, 0xb6, 0x56, 0x51, 0xfd, 0xf2, 0xc9, 0xb2, 0x16, 0x43, 0x75,
		0xd4, 0xc6, 0xfa, 0x6e, 0xb9, 0x6a, 0xec, 0x55, 0x76, 0xd7, 0x37, 0xcb, 0x9a, 0xca, 0x17, 0xec,
		0xdf, 0x8c, 0xc1, 0xb8, 0xf8, 0xee, 0xa5, 0x7f, 0x14, 0x1e, 0x62, 0x0b, 0x25, 0xae, 0xe5, 0x55,
		0x5f, 0x6b, 0x74, 0x70, 0x2e, 0xb6, 0x4c, 0x32, 0x2f, 0xfa, 0xd1, 0x70, 0x9a, 0x4a, 0xed, 0x58,
		0xde, 0x0b, 0x8d, 0x0e, 0xca, 0xb4, 0x96, 0xe9, 0xe9, 0x1b, 0x30, 0x67, 0x3b, 0x55, 0xd7, 0x33,
		0xed, 0xba, 0xd9, 0xa9, 0x57, 0x83, 0x25, 0xaa, 0xaa, 0x59, 0xab, 0x59, 0xae, 0xeb, 0x90, 0x39,
		0xd0, 0x67, 0x39, 0x6b, 0x3b, 0x3b, 0x54, 0x38, 0x98, 0x1c, 0x0a, 0x54, 0x54, 0x8a, 0x5c, 0xb5,
		0x5f, 0xe4, 0x3e, 0x02, 0xa9, 0x96, 0xd9, 0xae, 0x5a, 0xb6, 0xd7, 0x39, 0xc6, 0x15, 0x77, 0xd2,
		0x48, 0xb6, 0xcc, 0x76, 0x19, 0x5d, 0xff, 0x64, 0x5e, 0x7c, 0xfe, 0xb3, 0x0a, 0x19, 0xbe, 0xea,
		0x46, 0x2f, 0x31, 0x35, 0x3c, 0x41, 0x29, 0x78, 0x08, 0x7b, 0x6c, 0x60, 0x8d, 0xbe, 0x58, 0x42,
		0x33, 0x57, 0x7e, 0x84, 0xd4, 0xc2, 0x06, 0x41, 0xa2, 0xaa, 0x01, 0x85, 0x96, 0x45, 0x6a, 0x8f,
		0xa4, 0x41, 0xaf, 0xf4, 0xdb, 0x30, 0xf2, 0xb2, 0x8b, 0xb9, 0x47, 0x30, 0xf7, 0x85, 0xc1, 0xdc,
		0x77, 0x76, 0x30, 0x79, 0xea, 0xce, 0x4e, 0xb5, 0xb2, 0x65, 0x6c, 0x16, 0x36, 0x0c, 0x0a, 0xd7,
		0x1f, 0x86, 0x78, 0xd3, 0x7c, 0xe3, 0x58, 0x9c, 0xe3, 0x70, 0xd3, 0xb0, 0x86, 0x7f, 0x18, 0xe2,
		0xaf, 0x59, 0xe6, 0x2b, 0xe2, 0xcc, 0x82, 0x9b, 0x3e, 0xc4, 0xd0, 0xbf, 0x04, 0x09, 0x6c, 0x2f,
		0x1d, 0x80, 0x5a, 0x4c, 0x3b, 0xa5, 0x27, 0x21, 0x5e, 0xda, 0x32, 0x50, 0xf8, 0x6b, 0x90, 0x21,
		0xad, 0xd5, 0xed, 0xf5, 0x72, 0xa9, 0xac, 0xc5, 0x72, 0x57, 0x61, 0x84, 0x18, 0x01, 0xa5, 0x86,
		0x6f, 0x06, 0xed, 0x14, 0xbd, 0xa4, 0x1c, 0x0a, 0xeb, 0xdd, 0xdb, 0x2c, 0x96, 0x0d, 0x2d, 0xc6,
		0xbb, 0xd7, 0x85, 0x0c, 0x5f, 0x70, 0xff, 0x64, 0x62, 0xea, 0x1b, 0x0a, 0xa4, 0xb9, 0x02, 0x1a,
		0x55, 0x3e, 0x66, 0xb3, 0xe9, 0xbc, 0x56, 0x35, 0x9b, 0x0d, 0xd3, 0xa5, 0x41, 0x01, 0xb8, 0xa9,
		0x80, 0x5a, 0x86, 0x75, 0xda, 0x4f, 0x44, 0xf9, 0x2f, 0x28, 0xa0, 0xc9, 0xb5, 0xab, 0xa4, 0xa0,
		0xf2, 0x53, 0x55, 0xf0, 0x73, 0x0a, 0x8c, 0x8b, 0x05, 0xab, 0xa4, 0xde, 0xf9, 0x9f, 0xaa, 0x7a,
		0xdf, 0x89, 0xc1, 0x98, 0x50, 0xa6, 0x0e, 0xab, 0xdd, 0x2f, 0xc2, 0x64, 0xa3, 0x6e, 0xb5, 0xda,
		0x8e, 0x67, 0xd9, 0xb5, 0xe3, 0x6a, 0xd3, 0x7a, 0xd5, 0x6a, 0x66, 0x73, 0x78, 0xa0, 0xb8, 0x34,
		0xb8, 0x10, 0x5e, 0x5c, 0x0f, 0x70, 0x1b, 0x08, 0x96, 0x9f, 0x5a, 0x5f, 0x2d, 0x6f, 0x6e, 0x6f,
		0xed, 0x96, 0x2b, 0xa5, 0xbb, 0xd5, 0xbd, 0xca, 0xc7, 0x2a, 0x5b, 0x2f, 0x54, 0x0c, 0xad, 0x21,
		0x89, 0x7d, 0x88, 0xa9, 0xbe, 0x0d, 0x9a, 0xac, 0x94, 0xfe, 0x10, 0x84, 0xa9, 0xa5, 0x9d, 0xd2,
		0xa7, 0x60, 0xa2, 0xb2, 0x55, 0xdd, 0x59, 0x5f, 0x2d, 0x57, 0xcb, 0x6b, 0x6b, 0xe5, 0xd2, 0xee,
		0x0e, 0x59, 0xda, 0xf0, 0xa5, 0x77, 0xc5, 0xa4, 0xfe, 0xac, 0x0a, 0x53, 0x21, 0x9a, 0xe8, 0x05,
		0xfa, 0x52, 0x42, 0xde, 0x93, 0x9e, 0x1e, 0x46, 0xfb, 0x45, 0x54, 0x15, 0x6c, 0x9b, 0x1d, 0x8f,
		0xbe, 0xc3, 0x3c, 0x09, 0xc8, 0x4a, 0xb6, 0xd7, 0x38, 0x68, 0x58, 0x1d, 0xba, 0x12, 0x44, 0xde,
		0x54, 0x26, 0x82, 0x76, 0xb2, 0x18, 0xf4, 0x14, 0xe8, 0x6d, 0xc7, 0x6d, 0x78, 0x8d, 0x57, 0xad,
		0x6a, 0xc3, 0x66, 0xcb, 0x46, 0xe8, 0xcd, 0x25, 0x6e, 0x68, 0xac, 0x67, 0xdd, 0xf6, 0x7c, 0x69,
		0xdb, 0x3a, 0x34, 0x25, 0x69, 0x34, 0x80, 0xab, 0x86, 0xc6, 0x7a, 0x7c, 0xe9, 0xf3, 0x90, 0xa9,
		0x3b, 0x5d, 0x54, 0xce, 0x11, 0x39, 0x34, 0x5f, 0x28, 0x46, 0x9a, 0xb4, 0xf9, 0x22, 0xb4, 0x50,
		0x0f, 0xd6, 0xab, 0x32, 0x46, 0x9a, 0xb4, 0x11, 0x91, 0x27, 0x60, 0xc2, 0x3c, 0x3c, 0xec, 0x20,
		0x72, 0x46, 0x44, 0x5e, 0x3d, 0xc6, 0xfd, 0x66, 0x2c, 0x38, 0x73, 0x07, 0x92, 0xcc, 0x0e, 0x68,
		0x4a, 0x46, 0x96, 0xa8, 0xb6, 0xc9, 0xfb, 0x74, 0x6c, 0x3e, 0x65, 0x24, 0x6d, 0xd6, 0x79, 0x1e,
		0x32, 0x0d, 0xb7, 0x1a, 0x2c, 0xbf, 0xc7, 0xce, 0xc5, 0xe6, 0x93, 0x46, 0xba, 0xe1, 0xfa, 0x4b,
		0x97, 0xb9, 0x2f, 0xc7, 0x60, 0x5c, 0xdc, 0x3e, 0xd0, 0x57, 0x21, 0xd9, 0x74, 0x6a, 0x26, 0x0e,
		0x2d, 0xb2, 0x77, 0x35, 0x1f, 0xb1, 0xe3, 0xb0, 0xb8, 0x41, 0xe5, 0x0d, 0x1f, 0x39, 0xf3, 0xef,
		0x15, 0x48, 0xb2, 0x66, 0x7d, 0x1a, 0xe2, 0x6d, 0xd3, 0x3b, 0xc2, 0x74, 0x89, 0x62, 0x4c, 0x53,
		0x0c, 0x7c, 0x8d, 0xda, 0xdd, 0xb6, 0x69, 0xe3, 0x10, 0xa0, 0xed, 0xe8, 0x1a, 0xf9, 0xb5, 0x69,
		0x99, 0x75, 0xfc, 0x5e, 0xe3, 0xb4, 0x5a, 0x96, 0xed, 0xb9, 0xcc, 0xaf, 0xb4, 0xbd, 0x44, 0x9b,
		0xf5, 0x8f, 0xc0, 0xa4, 0xd7, 0x31, 0x1b, 0x4d, 0x41, 0x36, 0x8e, 0x65, 0x35, 0xd6, 0xe1, 0x0b,
		0xe7, 0xe1, 0x61, 0xc6, 0x5b, 0xb7, 0x3c, 0xb3, 0x76, 0x64, 0xd5, 0x03, 0xd0, 0x08, 0x5e, 0xbf,
		0x78, 0x88, 0x0a, 0xac, 0xd2, 0x7e, 0x86, 0xcd, 0xfd, 0x91, 0x02, 0x93, 0xec, 0x4d, 0xac, 0xee,
		0x1b, 0x6b, 0x13, 0xc0, 0xb4, 0x6d, 0xc7, 0xe3, 0xcd, 0xd5, 0x1b, 0xca, 0x3d, 0xb8, 0xc5, 0x82,
		0x0f, 0x32, 0x38, 0x82, 0x99, 0x16, 0x40, 0xd0, 0xd3, 0xd7, 0x6c, 0x73, 0x90, 0xa6, 0x7b, 0x43,
		0x78, 0x83, 0x91, 0xbc, 0xbb, 0x03, 0x69, 0x42, 0xaf, 0x6c, 0xfa, 0x69, 0x48, 0xec, 0x5b, 0x87,
		0x0d, 0x9b, 0xae, 0xf8, 0x92, 0x0b, 0xb6, 0xc2, 0x12, 0xf7, 0x57, 0x58, 0x8a, 0x2f, 0xc1, 0x54,
		0xcd, 0x69, 0xc9, 0xea, 0x16, 0x35, 0x69, 0xfd, 0xc0, 0x7d, 0x5e, 0xf9, 0x24, 0x04, 0x25, 0xe6,
		0x8f, 0x14, 0xe5, 0xd7, 0x63, 0xea, 0xed, 0xed, 0xe2, 0xef, 0xc4, 0x66, 0x6e, 0x13, 0xe8, 0x36,
		0x7b, 0x52, 0xc3, 0x3a, 0x68, 0x5a, 0x35, 0xa4, 0x3d, 0xfc, 0xd6, 0x47, 0xe0, 0xe9, 0xc3, 0x86,
		0x77, 0xd4, 0xdd, 0x5f, 0xac, 0x39, 0xad, 0x4b, 0x87, 0xce, 0xa1, 0x13, 0xec, 0xa9, 0xa2, 0x2b,
		0x7c, 0x81, 0x3f, 0xd1, 0x7d, 0xd5, 0x94, 0xdf, 0x3a, 0x13, 0xb9, 0x09, 0x9b, 0xaf, 0xc0, 0x14,
		0x15, 0xae, 0xe2, 0x8d, 0x1d, 0xf2, 0x7a, 0xa2, 0x0f, 0x5c, 0x1c, 0xcb, 0xfe, 0xee, 0xf7, 0xf0,
		0x74, 0x6d, 0x4c, 0x52, 0x28, 0xea, 0x23, 0x6f, 0x30, 0x79, 0x03, 0xce, 0x08, 0x7c, 0x24, 0x35,
		0xad, 0x4e, 0x04, 0xe3, 0x37, 0x29, 0xe3, 0x14, 0xc7, 0xb8, 0x43, 0xa1, 0xf9, 0x12, 0x8c, 0x9d,
		0x84, 0xeb, 0xdf, 0x50, 0xae, 0x8c, 0xc5, 0x93, 0xdc, 0x86, 0x09, 0x4c, 0x52, 0xeb, 0xba, 0x9e,
		0xd3, 0xc2, 0xe3, 0xde, 0x60, 0x9a, 0x7f, 0xfb, 0x3d, 0x92, 0x2b, 0xe3, 0x08, 0x56, 0xf2, 0x51,
		0xf9, 0x3c, 0xe0, 0xbd, 0xac, 0xba, 0x55, 0x6b, 0x46, 0x30, 0xdc, 0xa3, 0x8a, 0xf8, 0xf2, 0xf9,
		0x4f, 0xc0, 0x69, 0xf4, 0x19, 0x0f, 0x4b, 0xbc, 0x26, 0xd1, 0x2b, 0x69, 0xd9, 0x3f, 0xfa, 0x14,
		0x49, 0xc7, 0x29, 0x9f, 0x80, 0xd3, 0x89, 0xf3, 0xe2, 0xa1, 0xe5, 0x79, 0x56, 0xc7, 0xad, 0x9a,
		0xcd, 0x30, 0xf5, 0xb8, 0xa5, 0x88, 0xec, 0xaf, 0xfd, 0x40, 0xf4, 0xe2, 0x6d, 0x82, 0x2c, 0x34,
		0x9b, 0xf9, 0x3d, 0x78, 0x28, 0x24, 0x2a, 0x86, 0xe0, 0xfc, 0x2c, 0xe5, 0x3c, 0xdd, 0x13, 0x19,
		0x88, 0x76, 0x1b, 0x58, 0xbb, 0xef, 0xcb, 0x21, 0x38, 0xff, 0x3e, 0xe5, 0xd4, 0x29, 0x96, 0xb9,
		0x14, 0x31, 0xde, 0x81, 0xc9, 0x57, 0xad, 0xce, 0xbe, 0xe3, 0xd2, 0xe5, 0x9f, 0x21, 0xe8, 0x3e,
		0x47, 0xe9, 0x26, 0x28, 0x10, 0xaf, 0x07, 0x21, 0xae, 0x9b, 0x90, 0x3c, 0x30, 0x6b, 0xd6, 0x10,
		0x14, 0x9f, 0xa7, 0x14, 0xa3, 0x48, 0x1e, 0x41, 0x0b, 0x90, 0x39, 0x74, 0xe8, 0xcc, 0x14, 0x0d,
		0xff, 0x02, 0x85, 0xa7, 0x19, 0x86, 0x52, 0xb4, 0x9d, 0x76, 0xb7, 0x89, 0xa6, 0xad, 0x68, 0x8a,
		0x2f, 0x32, 0x0a, 0x86, 0xa1, 0x14, 0x27, 0x30, 0xeb, 0x5b, 0x8c, 0xc2, 0xe5, 0xec, 0xf9, 0x1c,
		0xa4, 0x1d, 0xbb, 0x79, 0xec, 0xd8, 0xc3, 0x28, 0xf1, 0x25, 0xca, 0x00, 0x14, 0x82, 0x08, 0x6e,
		0x41, 0x6a, 0x58, 0x47, 0xfc, 0xe6, 0x0f, 0x58, 0x7a, 0x30, 0x0f, 0xdc, 0x86, 0x09, 0x36, 0x40,
		0x35, 0x1c, 0x7b, 0x08, 0x8a, 0xdf, 0xa2, 0x14, 0xe3, 0x1c, 0x8c, 0x3e, 0x86, 0x67, 0xb9, 0xde,
		0xa1, 0x35, 0x0c, 0xc9, 0x97, 0xd9, 0x63, 0x50, 0x08, 0x35, 0xe5, 0xbe, 0x65, 0xd7, 0x8e, 0x86,
		0x63, 0xf8, 0x0a, 0x33, 0x25, 0xc3, 0x20, 0x8a, 0x12, 0x8c, 0xb5, 0xcc, 0x8e, 0x7b, 0x64, 0x36,
		0x87, 0x72, 0xc7, 0x6f, 0x53, 0x8e, 0x8c, 0x0f, 0xa2, 0x16, 0xe9, 0xda, 0x27, 0xa1, 0xf9, 0x1d,
		0x66, 0x11, 0x0e, 0x46, 0x53, 0xcf, 0xf5, 0xf0, 0x5a, 0xd9, 0x49, 0xd8, 0xfe, 0x01, 0x4b, 0x3d,
		0x82, 0xdd, 0xe4, 0x19, 0x6f, 0x41, 0xca, 0x6d, 0xbc, 0x31, 0x14, 0xcd, 0x3f, 0x64, 0x9e, 0xc6,
		0x00, 0x04, 0xbe, 0x0b, 0x0f, 0x87, 0x4e, 0x13, 0x43, 0x90, 0xfd, 0x23, 0x4a, 0x36, 0x1d, 0x32,
		0x55, 0xd0, 0x21, 0xe1, 0xa4, 0x94, 0xff, 0x98, 0x0d, 0x09, 0x96, 0xc4, 0xb5, 0x8d, 0xde, 0x15,
		0x5c, 0xf3, 0xe0, 0x64, 0x56, 0xfb, 0x27, 0xcc, 0x6a, 0x04, 0x2b, 0x58, 0x6d, 0x17, 0xa6, 0x29,
		0xe3, 0xc9, 0xfc, 0xfa, 0x55, 0x36, 0xb0, 0x12, 0xf4, 0x9e, 0xe8, 0xdd, 0x97, 0x60, 0xc6, 0x37,
		0x27, 0x2b, 0x4a, 0xdd, 0x6a, 0xcb, 0x6c, 0x0f, 0xc1, 0xfc, 0xbb, 0x94, 0x99, 0x8d, 0xf8, 0x7e,
		0x55, 0xeb, 0x6e, 0x9a, 0x6d, 0x44, 0xfe, 0x22, 0x64, 0x19, 0x79, 0xd7, 0xee, 0x58, 0x35, 0xe7,
		0xd0, 0x6e, 0xbc, 0x61, 0xd5, 0x87, 0xa0, 0xfe, 0x9a, 0xe4, 0xaa, 0x3d, 0x0e, 0x8e, 0x98, 0xd7,
		0x41, 0xf3, 0x6b, 0x95, 0x6a, 0xa3, 0xd5, 0x76, 0x3a, 0x5e, 0x04, 0xe3, 0x3f, 0x65, 0x9e, 0xf2,
		0x71, 0xeb, 0x18, 0x96, 0x2f, 0xc3, 0x38, 0xbe, 0x1c, 0x36, 0x24, 0x7f, 0x8f, 0x12, 0x8d, 0x05,
		0x28, 0x3a, 0x70, 0xd4, 0x9c, 0x56, 0xdb, 0xec, 0x0c, 0x33, 0xfe, 0xfd, 0x33, 0x36, 0x70, 0x50,
		0x08, 0x1d, 0x38, 0xbc, 0xe3, 0xb6, 0x85, 0x66, 0xfb, 0x21, 0x18, 0xbe, 0xce, 0x06, 0x0e, 0x86,
		0xa1, 0x14, 0xac, 0x60, 0x18, 0x82, 0xe2, 0x9f, 0x33, 0x0a, 0x86, 0x41, 0x14, 0x1f, 0x0f, 0x26,
		0xda, 0x8e, 0x75, 0xd8, 0x70, 0xbd, 0x0e, 0x29, 0x85, 0x07, 0x53, 0xfd, 0xfe, 0x0f, 0xc4, 0x22,
		0xcc, 0xe0, 0xa0, 0x68, 0x24, 0xa2, 0x4b, 0xa8, 0xf8, 0x4d, 0x29, 0x5a, 0xb1, 0x3f, 0x60, 0x23,
		0x11, 0x07, 0x43, 0xba, 0x71, 0x15, 0x22, 0x32, 0x7b, 0x0d, 0xbd, 0x1f, 0x0c, 0x41, 0xf7, 0x0d,
		0x49, 0xb9, 0x1d, 0x86, 0x45, 0x9c, 0x5c, 0xfd, 0xd3, 0xb5, 0x5f, 0xb1, 0x8e, 0x87, 0x8a, 0xce,
		0x7f, 0x21, 0xd5, 0x3f, 0x7b, 0x04, 0x49, 0xc6, 0x90, 0x09, 0xa9, 0x9e, 0xd2, 0xa3, 0x4e, 0x01,
		0x65, 0xff, 0xfc, 0x7b, 0xf4, 0x79, 0xc5, 0x72, 0x2a, 0xbf, 0x81, 0x82, 0x5c, 0x2c, 0x7a, 0xa2,
		0xc9, 0x3e, 0xf5, 0x9e, 0x1f, 0xe7, 0x42, 0xcd, 0x93, 0x5f, 0x83, 0x31, 0xa1, 0xe0, 0x89, 0xa6,
		0xfa, 0x0b, 0x94, 0x2a, 0xc3, 0xd7, 0x3b, 0xf9, 0xab, 0x10, 0x47, 0xc5, 0x4b, 0x34, 0xfc, 0x2f,
		0x52, 0x38, 0x16, 0xcf, 0x3f, 0x03, 0x49, 0x56, 0xb4, 0x44, 0x43, 0x7f, 0x99, 0x42, 0x7d, 0x08,
		0x82, 0xb3, 0x82, 0x25, 0x1a, 0xfe, 0x97, 0x18, 0x9c, 0x41, 0x10, 0x7c, 0x78, 0x13, 0xbe, 0xfd,
		0x57, 0xe2, 0x74, 0xd2, 0x61, 0xb6, 0xbb, 0x05, 0xa3, 0xb4, 0x52, 0x89, 0x46, 0xff, 0x0a, 0xbd,
		0x39, 0x43, 0xe4, 0xaf, 0x43, 0x62, 0x48, 0x83, 0xff, 0x35, 0x0a, 0x25, 0xf2, 0xf9, 0x12, 0xa4,
		0xb9, 0xea, 0x24, 0x1a, 0xfe, 0xd7, 0x29, 0x9c, 0x47, 0x21, 0xd5, 0x69, 0x75, 0x12, 0x4d, 0xf0,
		0x37, 0x98, 0xea, 0x14, 0x81, 0xcc, 0xc6, 0x0a, 0x93, 0x68, 0xf4, 0xdf, 0x64, 0x56, 0x67, 0x90,
		0xfc, 0x73, 0x90, 0xf2, 0x27, 0x9b, 0x68, 0xfc, 0xdf, 0xa2, 0xf8, 0x00, 0x83, 0x2c, 0xc0, 0x4d,
		0x76, 0xd1, 0x14, 0x7f, 0x9b, 0x59, 0x80, 0x43, 0xa1, 0x34, 0x92, 0x0b, 0x98, 0x68, 0xa6, 0x5f,
		0x65, 0x69, 0x24, 0xd5, 0x2f, 0xc8, 0x9b, 0x78, 0xcc, 0x8f, 0xa6, 0xf8, 0x3b, 0xcc, 0x9b, 0x58,
		0x1e, 0xa9, 0x21, 0x57, 0x04, 0xd1, 0x1c, 0x7f, 0x8f, 0xa9, 0x21, 0x15, 0x04, 0xf9, 0x6d, 0xd0,
		0x7b, 0xab, 0x81, 0x68, 0xbe, 0xcf, 0x50, 0xbe, 0xc9, 0x9e, 0x62, 0x20, 0xff, 0x02, 0x4c, 0x87,
		0x57, 0x02, 0xd1, 0xac, 0xbf, 0xf6, 0x9e, 0xf4, 0xee, 0xc6, 0x17, 0x02, 0xf9, 0xdd, 0x60, 0x4a,
		0xe1, 0xab, 0x80, 0x68, 0xda, 0xcf, 0xbe, 0x27, 0x0e, 0xdc, 0x7c, 0x11, 0x90, 0x2f, 0x00, 0x04,
		0x13, 0x70, 0x34, 0xd7, 0xe7, 0x28, 0x17, 0x07, 0x42, 0xa9, 0x41, 0xe7, 0xdf, 0x68, 0xfc, 0xe7,
		0x59, 0x6a, 0x50, 0x04, 0x4a, 0x0d, 0x36, 0xf5, 0x46, 0xa3, 0xbf, 0xc0, 0x52, 0x83, 0x41, 0x50,
		0x64, 0x73, 0xb3, 0x5b, 0x34, 0xc3, 0x97, 0x58, 0x64, 0x73, 0xa8, 0x7c, 0x05, 0x26, 0x7b, 0x26,
		0xc4, 0x68, 0xaa, 0x5f, 0xa7, 0x54, 0x9a, 0x3c, 0x1f, 0xf2, 0x93, 0x17, 0x9d, 0x0c, 0xa3, 0xd9,
		0x7e, 0x43, 0x9a, 0xbc, 0xe8, 0x5c, 0x98, 0xbf, 0x05, 0x49, 0xbb, 0xdb, 0x6c, 0xa2, 0xe4, 0xd1,
		0x07, 0x9f, 0xdc, 0xcb, 0xfe, 0xb7, 0x1f, 0x53, 0xeb, 0x30, 0x40, 0xfe, 0x2a, 0x24, 0xac, 0xd6,
		0xbe, 0x55, 0x8f, 0x42, 0xfe, 0xf7, 0x1f, 0xb3, 0x01, 0x13, 0x49, 0xe7, 0x9f, 0x03, 0x20, 0x4b,
		0x23, 0x78, 0xdb, 0x2f, 0x02, 0xfb, 0x3f, 0x7e, 0x4c, 0xcf, 0xd4, 0x04, 0x90, 0x80, 0x80, 0x9c,
		0xd0, 0x19, 0x4c, 0xf0, 0x03, 0x91, 0x00, 0x7b, 0xe4, 0x26, 0x8c, 0xbe, 0xec, 0x3a, 0xb6, 0x67,
		0x1e, 0x46, 0xa1, 0xff, 0x27, 0x45, 0x33, 0x79, 0x64, 0xb0, 0x96, 0xd3, 0xb1, 0x3c, 0xf3, 0xd0,
		0x8d, 0xc2, 0xfe, 0x2f, 0x8a, 0xf5, 0x01, 0x08, 0x5c, 0x33, 0x5d, 0x6f, 0x98, 0xe7, 0xfe, 0xdf,
		0x0c, 0xcc, 0x00, 0x48, 0x69, 0xf4, 0xf9, 0x15, 0xeb, 0x38, 0x0a, 0xfb, 0x43, 0xa6, 0x34, 0x95,
		0xcf, 0x3f, 0x03, 0x29, 0xf4, 0x91, 0x1c, 0x94, 0x8b, 0x00, 0xff, 0x1f, 0x0a, 0x0e, 0x10, 0xe8,
		0xce, 0xae, 0x57, 0xf7, 0x1a, 0xd1, 0xc6, 0xfe, 0x63, 0xea, 0x69, 0x26, 0x9f, 0x2f, 0x40, 0xda,
		0xf5, 0xea, 0xf5, 0x2e, 0xad, 0x4f, 0x23, 0xe0, 0xff, 0xf7, 0xc7, 0xfe, 0x92, 0x85, 0x8f, 0x41,
		0xde, 0x7e, 0xed, 0x15, 0xaf, 0xed, 0xe0, 0x6d, 0x8e, 0x28, 0x86, 0xf7, 0x28, 0x03, 0x07, 0x29,
		0x96, 0xc3, 0x97, 0x6f, 0xe1, 0xb6, 0x73, 0xdb, 0x21, 0x0b, 0xb7, 0x9f, 0xcc, 0x45, 0xaf, 0xc0,
		0xc2, 0x7f, 0x69, 0xc2, 0xf5, 0xbe, 0x62, 0x68, 0x2a, 0xbe, 0x54, 0x73, 0x5a, 0xfb, 0x8e, 0x7b,
		0x69, 0xdf, 0xf1, 0x8e, 0x2e, 0x79, 0x47, 0x16, 0x6a, 0xa3, 0x4b, 0xb6, 0x71, 0xf4, 0x79, 0xe6,
		0x64, 0xeb, 0xbc, 0x78, 0x17, 0xbf, 0xd2, 0x40, 0x8f, 0x56, 0xc1, 0x1b, 0x29, 0xfa, 0x59, 0x18,
		0xc1, 0x0f, 0x7b, 0x19, 0x6f, 0x56, 0x2a, 0xc5, 0xf8, 0xbd, 0x77, 0xe6, 0x4e, 0x19, 0xb4, 0xcd,
		0xef, 0x5d, 0xc6, 0x2b, 0xdd, 0x31, 0xa1, 0x77, 0xd9, 0xef, 0xbd, 0x42, 0x16, 0xbb, 0x85, 0xde,
		0x2b, 0x7e, 0xef, 0x0a, 0x5e, 0xf6, 0x56, 0x85, 0xde, 0x15, 0xbf, 0xf7, 0x2a, 0xde, 0xda, 0x19,
		0x13, 0x7a, 0xaf, 0xfa, 0xbd, 0xd7, 0xf0, 0x86, 0x4e, 0x5c, 0xe8, 0xbd, 0xe6, 0xf7, 0x5e, 0xc7,
		0x7b, 0x39, 0x93, 0x42, 0xef, 0x75, 0xbf, 0xf7, 0x06, 0xde, 0xc3, 0xd1, 0x85, 0xde, 0x1b, 0x7e,
		0xef, 0x4d, 0x7c, 0xf2, 0x6a, 0x54, 0xe8, 0xbd, 0xa9, 0xcf, 0xc2, 0x28, 0x79, 0xf2, 0x25, 0xbc,
		0xe1, 0x3f, 0x41, 0xbb, 0x59, 0x63, 0xd0, 0x7f, 0x19, 0x9f, 0xb2, 0x1a, 0x11, 0xfb, 0x2f, 0x07,
		0xfd, 0xcb, 0xf8, 0x0b, 0x1f, 0x9a, 0xd8, 0xbf, 0x1c, 0xf4, 0x5f, 0xc9, 0x8e, 0xe1, 0x93, 0x66,
		0x42, 0xff, 0x95, 0xa0, 0x7f, 0x25, 0x3b, 0x8e, 0x32, 0x46, 0xec, 0x5f, 0x09, 0xfa, 0xaf, 0x66,
		0x27, 0xce, 0x29, 0xf3, 0x19, 0xb1, 0xff, 0x6a, 0xee, 0x97, 0xb0, 0x7b, 0xed, 0xc0, 0xbd, 0xd3,
		0xa2, 0x7b, 0x7d, 0xc7, 0x4e, 0x8b, 0x8e, 0xf5, 0x5d, 0x3a, 0x2d, 0xba, 0xd4, 0x77, 0xe6, 0xb4,
		0xe8, 0x4c, 0xdf, 0x8d, 0xd3, 0xa2, 0x1b, 0x7d, 0x07, 0x4e, 0x8b, 0x0e, 0xf4, 0x5d, 0x37, 0x2d,
		0xba, 0xce, 0x77, 0xda, 0xb4, 0xe8, 0x34, 0xdf, 0x5d, 0xd3, 0xa2, 0xbb, 0x7c, 0x47, 0x65, 0x25,
		0x47, 0x05, 0x2e, 0xca, 0x4a, 0x2e, 0x0a, 0x9c, 0x93, 0x95, 0x9c, 0x13, 0xb8, 0x25, 0x2b, 0xb9,
		0x25, 0x70, 0x48, 0x56, 0x72, 0x48, 0xe0, 0x8a, 0xac, 0xe4, 0x8a, 0xc0, 0x09, 0x34, 0xc7, 0x0c,
		0xab, 0x1d, 0x92, 0x63, 0xea, 0xc0, 0x1c, 0x53, 0x07, 0xe6, 0x98, 0x3a, 0x30, 0xc7, 0xd4, 0x81,
		0x39, 0xa6, 0x0e, 0xcc, 0x31, 0x75, 0x60, 0x8e, 0xa9, 0x03, 0x73, 0x4c, 0x1d, 0x98, 0x63, 0xea,
		0xe0, 0x1c, 0x53, 0x23, 0x72, 0x4c, 0x8d, 0xc8, 0x31, 0x35, 0x22, 0xc7, 0xd4, 0x88, 0x1c, 0x53,
		0x23, 0x72, 0x4c, 0xed, 0x9b, 0x63, 0x81, 0x7b, 0xa7, 0x45, 0xf7, 0x86, 0xe6, 0x98, 0xda, 0x27,
		0xc7, 0xd4, 0x3e, 0x39, 0xa6, 0xf6, 0xc9, 0x31, 0xb5, 0x4f, 0x8e, 0xa9, 0x7d, 0x72, 0x4c, 0xed,
		0x93, 0x63, 0x6a, 0x9f, 0x1c, 0x53, 0xfb, 0xe5, 0x98, 0xda, 0x37, 0xc7, 0xd4, 0xbe, 0x39, 0xa6,
		0xf6, 0xcd, 0x31, 0xb5, 0x6f, 0x8e, 0xa9, 0x7d, 0x73, 0x4c, 0xe5, 0x73, 0xec, 0x5f, 0xaa, 0xa0,
		0x93, 0x1c, 0xdb, 0xc6, 0x47, 0xc6, 0xa8, 0x2b, 0x66, 0xa5, 0x4c, 0x1b, 0x41, 0xae, 0xd3, 0x02,
		0x97, 0xcc, 0x4a, 0xb9, 0x26, 0xf6, 0x2f, 0xfb, 0xfd, 0x2c, 0xdb, 0xc4, 0xfe, 0x2b, 0x7e, 0x3f,
		0xcb, 0x37, 0xb1, 0x7f, 0xc5, 0xef, 0x67, 0x19, 0x27, 0xf6, 0x5f, 0xf5, 0xfb, 0x59, 0xce, 0x89,
		0xfd, 0xd7, 0xfc, 0x7e, 0x96, 0x75, 0x62, 0xff, 0x75, 0xbf, 0x9f, 0xe5, 0x9d, 0xd8, 0x7f, 0xc3,
		0xef, 0x67, 0x99, 0x27, 0xf6, 0xdf, 0xd4, 0xcf, 0xc9, 0xb9, 0xc7, 0x04, 0x7c, 0xd7, 0x9e, 0x93,
		0xb3, 0x4f, 0x92, 0xb8, 0x1c, 0x48, 0xb0, 0xfc, 0x93, 0x24, 0x96, 0x03, 0x09, 0x96, 0x81, 0x92,
		0xc4, 0x95, 0xdc, 0xa7, 0xb1, 0xfb, 0x6c, 0xd9, 0x7d, 0x33, 0x92, 0xfb, 0x62, 0x9c, 0xeb, 0x66,
		0x24, 0xd7, 0xc5, 0x38, 0xb7, 0xcd, 0x48, 0x6e, 0x8b, 0x71, 0x2e, 0x9b, 0x91, 0x5c, 0x16, 0xe3,
		0xdc, 0x35, 0x23, 0xb9, 0x2b, 0xc6, 0xb9, 0x6a, 0x46, 0x72, 0x55, 0x8c, 0x73, 0xd3, 0x8c, 0xe4,
		0xa6, 0x18, 0xe7, 0xa2, 0x19, 0xc9, 0x45, 0x31, 0xce, 0x3d, 0x33, 0x92, 0x7b, 0x62, 0x9c, 0x6b,
		0xce, 0xca, 0xae, 0x89, 0xf1, 0x6e, 0x39, 0x2b, 0xbb, 0x25, 0xc6, 0xbb, 0xe4, 0xac, 0xec, 0x92,
		0x18, 0xef, 0x8e, 0xb3, 0xb2, 0x3b, 0x62, 0xbc, 0x2b, 0xfe, 0x24, 0xc6, 0x2a, 0xc2, 0x1d, 0xaf,
		0xd3, 0xad, 0x79, 0xef, 0xab, 0x22, 0x5c, 0x12, 0xca, 0x87, 0xf4, 0xb2, 0xbe, 0x88, 0x0b, 0x56,
		0xbe, 0xe2, 0x94, 0x66, 0xb0, 0x25, 0xa1, 0xb0, 0xe0, 0x10, 0x76, 0x38, 0x62, 0xe5, 0x7d, 0xd5,
		0x86, 0x4b, 0x42, 0x99, 0x11, 0xad, 0xdf, 0x8d, 0x0f, 0xbd, 0x62, 0x7b, 0x3b, 0xc6, 0x2a, 0x36,
		0x6a, 0xfe, 0x93, 0x56, 0x6c, 0x0b, 0xd1, 0x26, 0xf7, 0x8d, 0xbd, 0x10, 0x6d, 0xec, 0x9e, 0x59,
		0x67, 0xd8, 0x0a, 0x6e, 0x21, 0xda, 0xb4, 0xbe, 0x51, 0x3f, 0xd8, 0x7a, 0x8b, 0x46, 0xb0, 0x61,
		0xb5, 0x43, 0x22, 0xf8, 0xa4, 0xf5, 0xd6, 0x92, 0x30, 0x94, 0x9c, 0x34, 0x82, 0xd5, 0x13, 0x47,
		0xf0, 0x49, 0x2b, 0xaf, 0x25, 0x61, 0x78, 0x39, 0x71, 0x04, 0x7f, 0x08, 0xf5, 0x10, 0x8d, 0xe0,
		0xc0, 0xfc, 0x27, 0xad, 0x87, 0x16, 0xa2, 0x4d, 0x1e, 0x1a, 0xc1, 0xea, 0x09, 0x22, 0x78, 0x98,
		0xfa, 0x68, 0x21, 0xda, 0xb4, 0xe1, 0x11, 0xfc, 0xbe, 0xab, 0x99, 0x2f, 0x2a, 0x30, 0x59, 0x69,
		0xd4, 0xcb, 0xad, 0x7d, 0xab, 0x5e, 0xb7, 0xea, 0xd4, 0x8e, 0x4b, 0xc2, 0x48, 0xd0, 0xc7, 0xd5,
		0xdf, 0x7a, 0x67, 0x2e, 0xb0, 0xf0, 0x55, 0x48, 0x12, 0x9b, 0x2e, 0x2d, 0x65, 0xef, 0x29, 0x11,
		0x23, 0x9c, 0x2f, 0xaa, 0x9f, 0x67, 0xb0, 0xcb, 0x4b, 0xd9, 0xff, 0xa0, 0x70, 0xa3, 0x9c, 0xdf,
		0x9c, 0xfb, 0x55, 0xac, 0xa1, 0xfd, 0xbe, 0x35, 0xbc, 0x34, 0x94, 0x86, 0x9c, 0x6e, 0x8f, 0xf4,
		0xe8, 0xc6, 0x69, 0xd5, 0x85, 0x89, 0x4a, 0xa3, 0x5e, 0xc1, 0x3f, 0x35, 0x30, 0x8c, 0x4a, 0x44,
		0x46, 0x1a, 0x0f, 0x96, 0x84, 0xb0, 0xe4, 0x11, 0x7e, 0x48, 0x8b, 0x63, 0x44, 0xae, 0x81, 0x6e,
		0x6b, 0x0b, 0xb7, 0x5d, 0xe8, 0x77, 0xdb, 0x60, 0x64, 0xf7, 0x6f, 0xb8, 0xd0, 0xef, 0x86, 0x41,
		0x0e, 0xf9, 0xb7, 0x7a, 0x9d, 0x4d, 0xce, 0xe4, 0xe0, 0x96, 0x7e, 0x16, 0x62, 0xeb, 0xe4, 0x5c,
		0x79, 0xa6, 0x98, 0x41, 0x4a, 0x7d, 0xfb, 0x9d, 0xb9, 0xf8, 0x5e, 0xb7, 0x51, 0x37, 0x62, 0xeb,
		0x75, 0xfd, 0x0e, 0x24, 0x3e, 0x41, 0xbf, 0xf0, 0x8a, 0x04, 0x56, 0xa8, 0xc0, 0x53, 0x11, 0x4b,
		0x4c, 0x98, 0x7a, 0x71, 0xaf, 0x61, 0x7b, 0x97, 0x97, 0x6f, 0x18, 0x84, 0x22, 0xf7, 0xa7, 0x00,
		0xc8, 0x3d, 0x57, 0x4d, 0xf7, 0x48, 0xaf, 0x30, 0x66, 0x72, 0xeb, 0x1b, 0xdf, 0x7e, 0x67, 0x6e,
		0x65, 0x18, 0xd6, 0xa7, 0xeb, 0xa6, 0x7b, 0xf4, 0xb4, 0x77, 0xdc, 0xb6, 0x16, 0x8b, 0xc7, 0x9e,
		0xe5, 0x32, 0xf6, 0x36, 0x9b, 0xf5, 0xe8, 0x73, 0x65, 0xb9, 0xe7, 0x4a, 0x0a, 0xcf, 0xb4, 0x26,
		0x3e, 0xd3, 0xd2, 0x83, 0x3e, 0xcf, 0xeb, 0x6c, 0x92, 0x90, 0x2c, 0xa9, 0x46, 0x59, 0x52, 0x7d,
		0xbf, 0x96, 0x6c, 0xb3, 0xf1, 0x51, 0x7a, 0x56, 0x75, 0xd0, 0xb3, 0xaa, 0xef, 0xe7, 0x59, 0xff,
		0x1f, 0xc9, 0x56, 0x3f, 0x9f, 0xf6, 0x6c, 0x72, 0xa6, 0xf5, 0x67, 0x6b, 0x2d, 0xe8, 0x03, 0xad,
		0x02, 0xf2, 0xf1, 0x7b, 0x6f, 0xcd, 0x29, 0xb9, 0x2f, 0xc6, 0xd8, 0x93, 0x93, 0x44, 0x7a, 0xb0,
		0x27, 0xff, 0x59, 0xa9, 0xa9, 0x3e, 0x0c, 0x0b, 0x7d, 0x41, 0x81, 0xe9, 0x9e, 0x91, 0x9c, 0x98,
		0xe9, 0x83, 0x1d, 0xce, 0xed, 0x93, 0x0e, 0xe7, 0x54, 0xc1, 0xdf, 0x53, 0xe0, 0xb4, 0x34, 0xbc,
		0x12, 0xf5, 0x2e, 0x49, 0xea, 0x3d, 0xd4, 0x7b, 0x27, 0x2c, 0xc8, 0x69, 0xc7, 0xbb, 0x57, 0x02,
		0x70, 0xcc, 0xbe, 0xdf, 0x57, 0x24, 0xbf, 0x9f, 0xf5, 0x01, 0x21, 0xe6, 0x62, 0x11, 0x40, 0xd5,
		0x76, 0x20, 0xbe, 0xdb, 0xb1, 0x2c, 0x7d, 0x16, 0x62, 0x5b, 0x1d, 0xaa, 0xe1, 0x38, 0xc1, 0x6f,
		0x75, 0x8a, 0x1d, 0xd3, 0xae, 0x1d, 0x19, 0xb1, 0xad, 0x8e, 0x7e, 0x1e, 0xd4, 0x02, 0xfd, 0xb2,
		0x7d, 0x7a, 0x79, 0x82, 0x08, 0x14, 0xec, 0x3a, 0x95, 0x40, 0x7d, 0xfa, 0x2c, 0xc4, 0x37, 0x2c,
		0xf3, 0x80, 0x2a, 0x01, 0x44, 0x06, 0xb5, 0x18, 0xb8, 0x9d, 0xde, 0xf0, 0x45, 0x48, 0x32, 0x62,
		0xfd, 0x02, 0x42, 0x1c, 0x78, 0xf4, 0xb6, 0x14, 0x81, 0xd4, 0xa1, 0x33, 0x17, 0xee, 0xd5, 0x2f,
		0x42, 0xc2, 0x68, 0x1c, 0x1e, 0x79, 0xf4, 0xe6, 0xbd, 0x62, 0xa4, 0x3b, 0x77, 0x17, 0x52, 0xbe,
		0x46, 0x1f, 0x30, 0xf5, 0x2a, 0x79, 0x34, 0x7d, 0x86, 0x9f, 0x4f, 0xd8, 0xba, 0x25, 0x69, 0xd2,
		0xcf, 0x41, 0x72, 0xc7, 0xeb, 0x04, 0x83, 0x3e, 0xab, 0x48, 0xfd, 0xd6, 0xdc, 0x2f, 0x29, 0x90,
		0x5c, 0xb5, 0xac, 0x36, 0x36, 0xf8, 0xe3, 0x10, 0x5f, 0x75, 0x5e, 0xb3, 0xa9, 0x82, 0x93, 0xd4,
		0xa2, 0xa8, 0x9b, 0xda, 0x14, 0x77, 0xeb, 0x8f, 0xf3, 0x76, 0x9f, 0xf2, 0xed, 0xce, 0xc9, 0x61,
		0xdb, 0xe7, 0x04, 0xdb, 0x53, 0x07, 0x22, 0xa1, 0x1e, 0xfb, 0x5f, 0x87, 0x34, 0x77, 0x17, 0x7d,
		0x9e, 0xaa, 0x11, 0x93, 0x81, 0xbc, 0xad, 0x90, 0x44, 0xce, 0x82, 0x31, 0xe1, 0xc6, 0x08, 0xca,
		0x99, 0xb8, 0x0f, 0x14, 0x9b, 0x79, 0x41, 0x34, 0x73, 0xb8, 0x28, 0x35, 0xf5, 0x12, 0xb1, 0x11,
		0x36, 0xf7, 0x05, 0x12, 0x9c, 0xfd, 0x9d, 0x88, 0x3e, 0xe7, 0x12, 0xa0, 0x56, 0x1a, 0xcd, 0xdc,
		0x33, 0x00, 0x24, 0xe5, 0xcb, 0x76, 0xb7, 0x25, 0x65, 0xdd, 0x38, 0x33, 0xf0, 0xee, 0x91, 0xb5,
		0x6b, 0xb9, 0x58, 0x44, 0xac, 0xa7, 0xd0, 0x00, 0x03, 0x24, 0xc5, 0x30, 0xfe, 0xc9, 0x48, 0x7c,
		0x68, 0x25, 0x86, 0x44, 0xb3, 0x44, 0xf4, 0xae, 0xe5, 0x15, 0x6c, 0xc7, 0x3b, 0xb2, 0x3a, 0x12,
		0x62, 0x59, 0xbf, 0x22, 0x24, 0xec, 0xf8, 0xf2, 0x23, 0x3e, 0xa2, 0x2f, 0xe8, 0x4a, 0xee, 0xab,
		0x58, 0x41, 0x54, 0x0a, 0xf4, 0x3c, 0xa0, 0x3a, 0xc4, 0x03, 0xea, 0xd7, 0x84, 0xfa, 0x6d, 0x80,
		0x9a, 0xd2, 0xab, 0xe5, 0x4d, 0xe1, 0x3d, 0x67, 0xb0, 0xb2, 0xe2, 0x3b, 0x26, 0xb3, 0x29, 0x53,
		0xf9, 0xc9, 0x48, 0x95, 0xfb, 0x54, 0xb7, 0x27, 0xb5, 0xa9, 0x3a, 0xac, 0x4d, 0xbf, 0xe1, 0x57,
		0x1c, 0xe4, 0x17, 0x4d, 0xf0, 0x6f, 0x01, 0xe9, 0x4f, 0x45, 0xfa, 0x3e, 0xaf, 0x94, 0x7c, 0x55,
		0x57, 0x86, 0x75, 0x7f, 0x3e, 0x56, 0x2c, 0xfa, 0xea, 0x5e, 0x3f, 0x41, 0x08, 0xe4, 0x63, 0xa5,
		0x92, 0x3f, 0x6c, 0x27, 0x3f, 0xfd, 0xd6, 0x9c, 0xf2, 0x95, 0xb7, 0xe6, 0x4e, 0xe5, 0x7e, 0x5b,
		0x81, 0x49, 0x2a, 0xc9, 0x05, 0xee, 0xd3, 0x92, 0xf2, 0x67, 0xd8, 0x98, 0x11, 0x66, 0x81, 0x9f,
		0x58, 0xf0, 0x7e, 0x53, 0x81, 0x6c, 0x8f, 0xae, 0xcc, 0xde, 0x4b, 0x43, 0xa9, 0x9c, 0x57, 0xca,
		0x3f, 0x7d, 0x9b, 0xdf, 0x85, 0xc4, 0x6e, 0xa3, 0x65, 0x75, 0xd0, 0x4c, 0x80, 0x3e, 0x10, 0x95,
		0xd9, 0x66, 0x0e, 0x69, 0x62, 0x7d, 0x44, 0x39, 0xa1, 0x6f, 0x59, 0xcf, 0x42, 0x7c, 0xd5, 0xf4,
		0x4c, 0xac, 0x41, 0xc6, 0x1f, 0x5f, 0x4d, 0xcf, 0xcc, 0x5d, 0x81, 0xcc, 0xe6, 0x31, 0x3e, 0x88,
		0x54, 0xc7, 0x67, 0x50, 0xc4, 0xea, 0x8f, 0xd5, 0xab, 0x97, 0x17, 0x12, 0xc9, 0xba, 0x76, 0x4f,
		0xc9, 0xc7, 0xb1, 0x3e, 0xaf, 0xc2, 0xf8, 0x16, 0x52, 0x1b, 0xe3, 0x30, 0xec, 0x1c, 0x28, 0x9b,
		0x62, 0x21, 0xc4, 0xb3, 0x1a, 0xca, 0xa6, 0x54, 0x3e, 0xaa, 0xbe, 0x79, 0xa4, 0xb2, 0x4d, 0xf5,
		0xcb, 0xb6, 0x85, 0x78, 0x72, 0x5c, 0x9b, 0x5c, 0x88, 0x27, 0x41, 0x1b, 0xa3, 0xf7, 0xfd, 0x77,
		0x2a, 0x68, 0xa4, 0xd4, 0x59, 0xb5, 0x0e, 0x1a, 0x76, 0xc3, 0xeb, 0xad, 0x57, 0x7d, 0x8d, 0xf5,
		0xe7, 0x20, 0x85, 0x4c, 0xba, 0x46, 0x7f, 0x12, 0x10, 0x99, 0xfe, 0x3c, 0x2d, 0x51, 0x24, 0x0a,
		0xda, 0x80, 0x43, 0x27, 0xc0, 0xe8, 0x6b, 0xa0, 0x56, 0x2a, 0x9b, 0x74, 0x72, 0x5b, 0x19, 0x08,
		0xa5, 0x87, 0x7d, 0xe8, 0x15, 0x6d, 0x73, 0x0f, 0x0d, 0x44, 0xa0, 0xaf, 0x40, 0xac, 0xb2, 0x49,
		0x0b, 0xde, 0x0b, 0xc3, 0xd0, 0x18, 0xb1, 0xca, 0xe6, 0xcc, 0xbf, 0x52, 0x60, 0x4c, 0x68, 0xd5,
		0x73, 0x90, 0x21, 0x0d, 0xdc, 0xe3, 0x8e, 0x18, 0x42, 0x1b, 0xd3, 0x39, 0xf6, 0x3e, 0x75, 0x9e,
		0x29, 0xc0, 0x84, 0xd4, 0xae, 0x2f, 0x82, 0xce, 0x37, 0x51, 0x25, 0xc8, 0xcf, 0x91, 0x85, 0xf4,
		0xe4, 0x1e, 0x05, 0x08, 0xec, 0xea, 0xff, 0x8a, 0x56, 0xa5, 0xbc, 0xb3, 0x5b, 0x5e, 0xd5, 0x94,
		0xdc, 0xd7, 0x15, 0x48, 0xd3, 0xb2, 0xb5, 0xe6, 0xb4, 0x2d, 0xbd, 0x08, 0x4a, 0x81, 0x46, 0xd0,
		0x83, 0xe9, 0xad, 0x14, 0xf4, 0x4b, 0xa0, 0x14, 0x87, 0x77, 0xb5, 0x52, 0xd4, 0x97, 0x41, 0x29,
		0x51, 0x07, 0x0f, 0xe7, 0x19, 0xa5, 0x94, 0xfb, 0x63, 0x15, 0xa6, 0xf8, 0x32, 0x9a, 0x8d, 0x27,
		0xe7, 0xc5, 0xf7, 0xa6, 0x7c, 0xea, 0xf2, 0xf2, 0x95, 0x95, 0x45, 0xf4, 0x8f, 0x1f, 0x92, 0x39,
		0xf1, 0x15, 0x2a, 0x0f, 0xbe, 0xc8, 0xe5, 0x7e, 0xe7, 0x44, 0xf2, 0x71, 0x8e, 0xa1, 0xe7, 0x9c,
		0x88, 0xd0, 0xdb, 0x73, 0x4e, 0x44, 0xe8, 0xed, 0x39, 0x27, 0x22, 0xf4, 0xf6, 0xec, 0x05, 0x08,
		0xbd, 0x3d, 0xe7, 0x44, 0x84, 0xde, 0x9e, 0x73, 0x22, 0x42, 0x6f, 0xef, 0x39, 0x11, 0xda, 0xdd,
		0xf7, 0x9c, 0x88, 0xd8, 0xdf, 0x7b, 0x4e, 0x44, 0xec, 0xef, 0x3d, 0x27, 0x92, 0x8f, 0x7b, 0x9d,
		0xae, 0xd5, 0x7f, 0xd7, 0x41, 0xc4, 0x0f, 0x7a, 0x09, 0x0c, 0x46, 0xe0, 0x2d, 0x98, 0x20, 0x0b,
		0x12, 0x25, 0xc7, 0xf6, 0xcc, 0x86, 0x6d, 0x75, 0xf4, 0x8f, 0x42, 0x86, 0x34, 0x91, 0xd7, 0x9c,
		0xb0, 0xd7, 0x40, 0xd2, 0x4f, 0xc7, 0x5b, 0x41, 0x3a, 0xf7, 0x27, 0x71, 0x98, 0x26, 0x0d, 0x15,
		0xb3, 0x65, 0x09, 0xa7, 0x8c, 0x2e, 0x4a, 0x7b, 0x4a, 0xe3, 0x08, 0x7e, 0xff, 0x9d, 0x39, 0xd2,
		0x5a, 0xf0, 0xa3, 0xe9, 0xa2, 0xb4, 0xbb, 0x24, 0xca, 0x05, 0x13, 0xd0, 0x45, 0xe9, 0xe4, 0x91,
		0x28, 0xe7, 0xcf, 0x37, 0xbe, 0x1c, 0x3b, 0x83, 0x24, 0xca, 0xad, 0xfa, 0x51, 0x76, 0x51, 0x3a,
		0x8d, 0x24, 0xca, 0x95, 0xfd, 0x78, 0xbb, 0x28, 0xed, 0x3d, 0x89, 0x72, 0x6b, 0x7e, 0xe4, 0x5d,
		0x94, 0x76, 0xa1, 0x44, 0xb9, 0xdb, 0x7e, 0x0c, 0x5e, 0x94, 0xce, 0x2a, 0x89, 0x72, 0xcf, 0xfb,
		0xd1, 0x78, 0x51, 0x3a, 0xb5, 0x24, 0xca, 0xad, 0xfb, 0x71, 0x39, 0x2f, 0x9f, 0x5f, 0x12, 0x05,
		0xef, 0x04, 0x11, 0x3a, 0x2f, 0x9f, 0x64, 0x12, 0x25, 0x3f, 0x16, 0xc4, 0xea, 0xbc, 0x7c, 0xa6,
		0x49, 0x94, 0xdc, 0x08, 0xa2, 0x76, 0x5e, 0xde, 0x2b, 0x13, 0x25, 0x37, 0x83, 0xf8, 0x9d, 0x97,
		0x77, 0xcd, 0x44, 0xc9, 0x4a, 0x10, 0xc9, 0xf3, 0xf2, 0xfe, 0x99, 0x28, 0xb9, 0x15, 0x2c, 0xa2,
		0xff, 0xa1, 0x14, 0x7e, 0xdc, 0x29, 0xa8, 0x9c, 0x14, 0x7e, 0x10, 0x12, 0x7a, 0xd2, 0x40, 0xc6,
		0xc9, 0x04, 0x61, 0x97, 0x93, 0xc2, 0x0e, 0x42, 0x42, 0x2e, 0x27, 0x85, 0x1c, 0x84, 0x84, 0x5b,
		0x4e, 0x0a, 0x37, 0x08, 0x09, 0xb5, 0x9c, 0x14, 0x6a, 0x10, 0x12, 0x66, 0x39, 0x29, 0xcc, 0x20,
		0x24, 0xc4, 0x72, 0x52, 0x88, 0x41, 0x48, 0x78, 0xe5, 0xa4, 0xf0, 0x82, 0x90, 0xd0, 0xba, 0x20,
		0x87, 0x16, 0x84, 0x85, 0xd5, 0x05, 0x39, 0xac, 0x20, 0x2c, 0xa4, 0x1e, 0x93, 0x43, 0x2a, 0x75,
		0xff, 0x9d, 0xb9, 0x04, 0x6a, 0xe2, 0xa2, 0xe9, 0x82, 0x1c, 0x4d, 0x10, 0x16, 0x49, 0x17, 0xe4,
		0x48, 0x82, 0xb0, 0x28, 0xba, 0x20, 0x47, 0x11, 0x84, 0x45, 0xd0, 0xdb, 0x72, 0x04, 0x05, 0x67,
		0x7c, 0x72, 0xd2, 0x96, 0x62, 0x54, 0x04, 0xa9, 0x43, 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43,
		0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43, 0x44, 0x90, 0x3a, 0x44, 0x04, 0xa9, 0x43, 0x44, 0x90,
		0x3a, 0x4c, 0x04, 0xa9, 0x43, 0x45, 0x90, 0xda, 0x2f, 0x82, 0x2e, 0xc8, 0x27, 0x1e, 0x20, 0x6c,
		0x40, 0xba, 0x20, 0x6f, 0x7d, 0x46, 0x87, 0x90, 0x3a, 0x54, 0x08, 0xa9, 0xfd, 0x42, 0xe8, 0x0f,
		0x55, 0x98, 0x12, 0x42, 0x88, 0xee, 0x0f, 0x7d, 0x50, 0x23, 0xd0, 0xb5, 0x21, 0x0e, 0x58, 0x84,
		0xc5, 0xd4, 0xb5, 0x21, 0x36, 0xa9, 0x07, 0xc5, 0x59, 0xef, 0x28, 0x54, 0x1e, 0x62, 0x14, 0x5a,
		0xf3, 0x63, 0xe8, 0xda, 0x10, 0x07, 0x2f, 0x7a, 0x63, 0xef, 0xc6, 0xa0, 0x41, 0xe0, 0xf9, 0xa1,
		0x06, 0x81, 0xf5, 0xa1, 0x06, 0x81, 0x3b, 0x81, 0x07, 0x7f, 0x39, 0x06, 0xa7, 0x03, 0x0f, 0x92,
		0x4f, 0xf8, 0x97, 0xb5, 0x72, 0xdc, 0x16, 0x95, 0xce, 0xb6, 0x6d, 0x38, 0x37, 0xc6, 0xd6, 0xeb,
		0xfa, 0xb6, 0xb8, 0x59, 0x95, 0x3f, 0xe9, 0x06, 0x0e, 0xe7, 0x71, 0xba, 0x18, 0x7a, 0x01, 0xd4,
		0xf5, 0xba, 0x8b, 0x47, 0x8b, 0xb0, 0xdb, 0x96, 0x0c, 0xd4, 0xad, 0x1b, 0x30, 0x82, 0xc5, 0x5d,
		0xec, 0xde, 0xf7, 0x73, 0xe3, 0x55, 0x83, 0x32, 0xe5, 0xde, 0x56, 0xe0, 0x9c, 0x10, 0xca, 0x1f,
		0xcc, 0x96, 0xc1, 0xad, 0xa1, 0xb6, 0x0c, 0x84, 0x04, 0x09, 0xb6, 0x0f, 0x9e, 0xe8, 0xdd, 0xa9,
		0xe6, 0xb3, 0x44, 0xde, 0x4a, 0xf8, 0x73, 0x30, 0x1e, 0x3c, 0x01, 0x7e, 0x67, 0xbb, 0x1a, 0xbd,
		0x9a, 0x19, 0x96, 0x9a, 0x57, 0xa5, 0x55, 0xb4, 0x81, 0x30, 0x3f, 0x5b, 0x73, 0x79, 0x98, 0xa8,
		0x88, 0x5f, 0x89, 0x8a, 0x5a, 0x8c, 0x48, 0xa2, 0xd2, 0xfc, 0xde, 0x97, 0xe6, 0x4e, 0xe5, 0x9e,
		0x82, 0x0c, 0xff, 0xad, 0x27, 0x09, 0x98, 0x62, 0xc0, 0x7c, 0xfc, 0x5b, 0x48, 0xfa, 0xef, 0x2a,
		0x70, 0x86, 0x17, 0x7f, 0xa1, 0xe1, 0x1d, 0xad, 0xdb, 0xa8, 0xa6, 0x7f, 0x06, 0x92, 0x16, 0x75,
		0x1c, 0xfd, 0x91, 0x1c, 0xfa, 0x1e, 0x19, 0x2a, 0xbe, 0x88, 0xff, 0x35, 0x7c, 0x88, 0xb4, 0xc6,
		0xc1, 0x6e, 0xbb, 0x3c, 0xf3, 0x38, 0x24, 0x08, 0xbf, 0xa8, 0xd7, 0x98, 0xa4, 0xd7, 0x6f, 0x86,
		0xe8, 0x85, 0xe3, 0x48, 0xbf, 0x23, 0xe8, 0xc5, 0xbd, 0xae, 0x86, 0x8a, 0x2f, 0xb2, 0xe0, 0x2b,
		0x26, 0x51, 0xfd, 0x87, 0x23, 0x2a, 0x5a, 0xc9, 0x79, 0x48, 0x96, 0x65, 0x99, 0x70, 0x3d, 0x57,
		0x21, 0x5e, 0x71, 0xea, 0xf8, 0xe7, 0x7b, 0xf0, 0x0f, 0x61, 0x53, 0x23, 0xd3, 0x5f, 0xc5, 0xbe,
		0x08, 0xc9, 0xd2, 0x51, 0xa3, 0x59, 0xef, 0x58, 0x36, 0xdd, 0xb3, 0xa7, 0x4b, 0xe8, 0x08, 0x63,
		0xf8, 0x7d, 0xb9, 0x12, 0x4c, 0x56, 0x1c, 0xbb, 0x78, 0xec, 0xf1, 0xe3, 0xc6, 0xa2, 0x94, 0x22,
		0x74, 0xcf, 0x07, 0x7f, 0x4b, 0x04, 0x09, 0x14, 0x13, 0xdf, 0x7e, 0x67, 0x4e, 0xd9, 0xf5, 0xd7,
		0xcf, 0x37, 0xe1, 0x21, 0x9a, 0x3e, 0x3d, 0x54, 0xcb, 0x51, 0x54, 0x29, 0xba, 0x4f, 0xcd, 0xd1,
		0xad, 0x23, 0x3a, 0x3b, 0x94, 0xee, 0xc1, 0x34, 0x43, 0x45, 0xd1, 0x40, 0xcd, 0xd4, 0x13, 0x69,
		0x16, 0x4a, 0xb7, 0x18, 0x45, 0x27, 0x69, 0xf6, 0x18, 0xa4, 0xfc, 0x3e, 0x2e, 0x1a, 0xf8, 0x4c,
		0x59, 0x5e, 0xc8, 0x41, 0x9a, 0x4b, 0x58, 0x3d, 0x01, 0x4a, 0x41, 0x3b, 0x85, 0xfe, 0x2b, 0x6a,
		0x0a, 0xfa, 0xaf, 0xa4, 0xc5, 0x16, 0x1e, 0x87, 0x09, 0x69, 0xfd, 0x12, 0xf5, 0xac, 0x6a, 0x80,
		0xfe, 0x2b, 0x6b, 0xe9, 0x99, 0xf8, 0xa7, 0x7f, 0x63, 0xf6, 0xd4, 0xc2, 0x2d, 0xd0, 0x7b, 0x57,
		0x3a, 0xf5, 0x11, 0x88, 0x15, 0x10, 0xe5, 0x43, 0x10, 0x2b, 0x16, 0x35, 0x65, 0x66, 0xe2, 0x2f,
		0x7f, 0xfe, 0x5c, 0xba, 0x88, 0xbf, 0xd2, 0x7d, 0xd7, 0xf2, 0x8a, 0x45, 0x0a, 0x7e, 0x16, 0xce,
		0x84, 0xae, 0x94, 0x22, 0x7c, 0xa9, 0x44, 0xf0, 0xab, 0xab, 0x3d, 0xf8, 0xd5, 0x55, 0x8c, 0x57,
		0xf2, 0x6c, 0xc7, 0xb9, 0xa0, 0x87, 0xac, 0x4b, 0x66, 0xeb, 0xdc, 0x0e, 0x77, 0x21, 0xff, 0x2c,
		0x95, 0x2d, 0x86, 0xca, 0x5a, 0x11, 0x3b, 0xd6, 0xc5, 0x7c, 0x89, 0xe2, 0x4b, 0xa1, 0xf8, 0x03,
		0x69, 0x5b, 0x55, 0x9c, 0x21, 0x28, 0x49, 0xc9, 0x57, 0x78, 0x35, 0x94, 0xe4, 0x88, 0x3b, 0xec,
		0xbe, 0xea, 0x2b, 0x5c, 0x0e, 0x95, 0x6d, 0x44, 0x1c, 0xfa, 0x2a, 0xe7, 0x2f, 0xd1, 0x49, 0xbe,
		0x70, 0x59, 0x3f, 0xc3, 0x72, 0x54, 0x18, 0x81, 0xa9, 0x81, 0x98, 0x54, 0xbe, 0x44, 0x01, 0xc5,
		0xbe, 0x80, 0xfe, 0x56, 0x62, 0xc8, 0xfc, 0xf3, 0x94, 0xa4, 0xd4, 0x97, 0x24, 0xc2, 0x54, 0x0c,
		0x5e, 0xdc, 0xbd, 0xf7, 0xee, 0xec, 0xa9, 0x6f, 0xbd, 0x3b, 0x7b, 0xea, 0x3f, 0xbd, 0x3b, 0x7b,
		0xea, 0x3b, 0xef, 0xce, 0x2a, 0xdf, 0x7f, 0x77, 0x56, 0xf9, 0xe1, 0xbb, 0xb3, 0xca, 0x8f, 0xde,
		0x9d, 0x55, 0xde, 0xbc, 0x3f, 0xab, 0x7c, 0xe5, 0xfe, 0xac, 0xf2, 0xd5, 0xfb, 0xb3, 0xca, 0xef,
		0xdf, 0x9f, 0x55, 0xde, 0xbe, 0x3f, 0xab, 0xdc, 0xbb, 0x3f, 0xab, 0x7c, 0xeb, 0xfe, 0xac, 0xf2,
		0x9d, 0xfb, 0xb3, 0xca, 0xf7, 0xef, 0xcf, 0x9e, 0xfa, 0xe1, 0xfd, 0x59, 0xe5, 0x47, 0xf7, 0x67,
		0x4f, 0xbd, 0xf9, 0xdd, 0xd9, 0x53, 0x6f, 0x7d, 0x77, 0xf6, 0xd4, 0x57, 0xbe, 0x3b, 0xab, 0xc0,
		0x77, 0x56, 0xe0, 0x11, 0xe9, 0x9b, 0x64, 0xb8, 0x1a, 0xb8, 0xc2, 0x7e, 0xfe, 0xcb, 0x6f, 0x38,
		0xe1, 0x17, 0xca, 0x66, 0x1e, 0xf4, 0xeb, 0x6b, 0xb9, 0x7f, 0x9d, 0x80, 0x51, 0xb6, 0x0c, 0x1c,
		0xf6, 0x23, 0xe9, 0x57, 0x21, 0x79, 0xd4, 0x68, 0x9a, 0x9d, 0x86, 0x77, 0x4c, 0xd7, 0x3f, 0x1f,
		0x5e, 0x0c, 0xd4, 0x66, 0x2b, 0xa6, 0xcf, 0x77, 0x5b, 0x4e, 0xb7, 0x63, 0xf8, 0xa2, 0xfa, 0x39,
		0xc8, 0x1c, 0x59, 0x8d, 0xc3, 0x23, 0xaf, 0xda, 0xb0, 0xab, 0xb5, 0x16, 0x2e, 0x93, 0xc7, 0x0c,
		0x20, 0x6d, 0xeb, 0x76, 0xa9, 0x85, 0x6e, 0x56, 0x37, 0x3d, 0x13, 0xbf, 0x9e, 0x67, 0x0c, 0xfc,
		0x19, 0xff, 0xd0, 0xb1, 0xe5, 0x76, 0x9b, 0x5e, 0xb5, 0xe6, 0x74, 0x6d, 0x0f, 0x17, 0xb2, 0xaa,
		0x91, 0x26, 0x6d, 0x25, 0xd4, 0xa4, 0x3f, 0x06, 0x63, 0x5e, 0xa7, 0x6b, 0x55, 0xdd, 0x9a, 0xe3,
		0xb9, 0x2d, 0xd3, 0xc6, 0x85, 0x6c, 0xd2, 0xc8, 0xa0, 0xc6, 0x1d, 0xda, 0x86, 0x7f, 0x5f, 0xbf,
		0xe6, 0x74, 0x2c, 0xfc, 0x1e, 0x1d, 0x33, 0xc8, 0x85, 0xae, 0x81, 0xfa, 0x8a, 0x75, 0x8c, 0xdf,
		0xd4, 0xe2, 0x06, 0xfa, 0xa8, 0x3f, 0x09, 0x23, 0xe4, 0x0f, 0xe4, 0xe0, 0xb2, 0x1a, 0xef, 0x5a,
		0xfb, 0x8f, 0x46, 0x56, 0x67, 0x0d, 0x2a, 0xa0, 0xdf, 0x84, 0x51, 0xcf, 0xea, 0x74, 0xcc, 0x86,
		0x8d, 0xdf, 0x9a, 0xd2, 0xcb, 0x73, 0x21, 0x66, 0xd8, 0x25, 0x12, 0xf8, 0xe7, 0x80, 0x0d, 0x26,
		0xaf, 0x5f, 0x85, 0x0c, 0x96, 0x5b, 0xae, 0x92, 0x3f, 0x22, 0x94, 0xee, 0x1b, 0xc8, 0x69, 0x22,
		0xc7, 0x36, 0x09, 0x18, 0x8c, 0xfc, 0x14, 0xe2, 0x18, 0xbe, 0xed, 0x63, 0x21, 0xb7, 0xc5, 0x63,
		0xee, 0x32, 0xae, 0x17, 0xc9, 0xad, 0x29, 0x0f, 0xf9, 0xb1, 0xc4, 0x4d, 0xc8, 0xf0, 0x7a, 0x31,
		0x33, 0x90, 0xba, 0x07, 0x9b, 0xe1, 0x89, 0xe0, 0x0f, 0x34, 0xf4, 0xb1, 0x02, 0xe9, 0xcf, 0xc7,
		0x6e, 0x28, 0x33, 0xdb, 0xa0, 0xc9, 0xf7, 0x0b, 0xa1, 0xbc, 0x28, 0x52, 0x6a, 0xfc, 0xc3, 0xe2,
		0x25, 0xf2, 0x80, 0x31, 0xf7, 0x1c, 0x8c, 0x90, 0xf8, 0xd1, 0xd3, 0x30, 0x1a, 0xfc, 0xca, 0x66,
		0x12, 0xe2, 0xdb, 0x7b, 0x95, 0x1d, 0xf2, 0x73, 0xb9, 0x3b, 0x1b, 0x85, 0xed, 0x9d, 0xdd, 0xf5,
		0xd2, 0xc7, 0xb4, 0x98, 0x3e, 0x01, 0xe9, 0xe2, 0xfa, 0xc6, 0x46, 0xb5, 0x58, 0x58, 0xdf, 0x28,
		0xdf, 0xd5, 0xd4, 0xdc, 0x2c, 0x8c, 0x10, 0x3d, 0xf1, 0xcf, 0xfe, 0x75, 0x6d, 0xfb, 0x98, 0xd5,
		0x0d, 0xf8, 0x22, 0xf7, 0x35, 0x1d, 0x46, 0x0b, 0xcd, 0xe6, 0xa6, 0xd9, 0x76, 0xf5, 0x17, 0x60,
		0x92, 0xfc, 0x20, 0xc7, 0xae, 0xb3, 0x8a, 0x7f, 0x9d, 0x12, 0x8d, 0x0a, 0x0a, 0xfd, 0xc3, 0x14,
		0xc1, 0x73, 0x53, 0xf1, 0xc5, 0x1e, 0x59, 0x62, 0xe0, 0x5e, 0x0e, 0x7d, 0x17, 0x34, 0xd6, 0xb8,
		0xd6, 0x74, 0x4c, 0x0f, 0xf1, 0xc6, 0xe8, 0x8f, 0x47, 0xf6, 0xe7, 0x65, 0xa2, 0x84, 0xb6, 0x87,
		0x41, 0xff, 0x28, 0x24, 0xd7, 0x6d, 0xef, 0xca, 0x32, 0x62, 0x63, 0x7f, 0xf4, 0xa9, 0x97, 0x8d,
		0x89, 0x10, 0x16, 0x1f, 0x41, 0xd1, 0xd7, 0x56, 0x10, 0x3a, 0x3e, 0x08, 0x8d, 0x45, 0x02, 0x34,
		0xbe, 0xd4, 0x9f, 0x83, 0x14, 0x7a, 0x2d, 0x21, 0x37, 0x4f, 0xb0, 0x9a, 0xb5, 0x07, 0xee, 0xcb,
		0x10, 0x7c, 0x80, 0x61, 0x04, 0xe4, 0xfe, 0x23, 0x03, 0x09, 0x38, 0x05, 0x02, 0x0c, 0x22, 0xd8,
		0xf1, 0x35, 0x18, 0xed, 0x4b, 0xb0, 0x23, 0x69, 0xb0, 0xc3, 0x6b, 0xb0, 0xe3, 0x6b, 0x90, 0x1c,
		0x48, 0xc0, 0x6b, 0xe0, 0x5f, 0xeb, 0x45, 0x80, 0xb5, 0xc6, 0xeb, 0x56, 0x9d, 0xa8, 0x40, 0xfe,
		0x24, 0x54, 0x2e, 0x84, 0x21, 0x10, 0x22, 0x14, 0x1c, 0x4a, 0x2f, 0x43, 0x7a, 0xe7, 0x20, 0x20,
		0x81, 0x9e, 0x3c, 0xf6, 0xd5, 0x38, 0x90, 0x58, 0x78, 0x9c, 0xaf, 0x0a, 0x79, 0x98, 0xf4, 0x60,
		0x55, 0xb8, 0xa7, 0xe1, 0x50, 0x81, 0x2a, 0x84, 0x24, 0x13, 0xa1, 0x0a, 0xc7, 0xc2, 0xe3, 0xd0,
		0x60, 0x58, 0x74, 0x1c, 0x24, 0x49, 0x47, 0xa5, 0xb9, 0x10, 0x0a, 0x2a, 0x41, 0x07, 0x43, 0x7a,
		0x85, 0x3d, 0x82, 0x83, 0x1c, 0x81, 0xc7, 0xfb, 0x7b, 0x84, 0xc9, 0x30, 0x8f, 0xb0, 0x6b, 0x3e,
		0xcf, 0xf0, 0x51, 0x56, 0xc4, 0x33, 0x11, 0x99, 0x67, 0x4c, 0x54, 0xca, 0x33, 0xd6, 0xac, 0x7f,
		0x1c, 0x26, 0x58, 0x1b, 0x1a, 0x9e, 0x10, 0xa9, 0x46, 0xff, 0x68, 0x5e, 0x7f, 0x52, 0x2a, 0x49,
		0x38, 0x65, 0xbc, 0x5e, 0x81, 0x71, 0xd6, 0xb4, 0xe9, 0xe2, 0xc7, 0x9d, 0xa4, 0x7f, 0x0f, 0xa5,
		0x3f, 0x23, 0x11, 0x24, 0x84, 0x12, 0x7a, 0x66, 0x15, 0xa6, 0xc3, 0x47, 0x23, 0x7e, 0xf8, 0x4d,
		0x91, 0xe1, 0xf7, 0x34, 0x3f, 0xfc, 0x2a, 0xfc, 0xf0, 0x5d, 0x82, 0x33, 0xa1, 0x63, 0x4f, 0x14,
		0x49, 0x8c, 0x27, 0xb9, 0x05, 0x63, 0xc2, 0x90, 0xc3, 0x83, 0x13, 0x21, 0xe0, 0x44, 0x2f, 0x38,
		0x08, 0xad, 0x90, 0xd9, 0x43, 0x00, 0xab, 0x3c, 0xf8, 0xa3, 0x30, 0x2e, 0x8e, 0x37, 0x3c, 0x7a,
		0x2c, 0x04, 0x3d, 0x16, 0x82, 0x0e, 0xbf, 0x77, 0x3c, 0x04, 0x1d, 0x97, 0xd0, 0x3b, 0x7d, 0xef,
		0x3d, 0x19, 0x82, 0x9e, 0x0c, 0x41, 0x87, 0xdf, 0x5b, 0x0f, 0x41, 0xeb, 0x3c, 0xfa, 0x19, 0x98,
		0x90, 0x86, 0x18, 0x1e, 0x3e, 0x1a, 0x02, 0x1f, 0xe5, 0xe1, 0xcf, 0x82, 0x26, 0x0f, 0x2e, 0x3c,
		0x7e, 0x22, 0x04, 0x3f, 0x11, 0x76, 0xfb, 0x70, 0xed, 0x47, 0x42, 0xe0, 0x23, 0xa1, 0xb7, 0x0f,
		0xc7, 0x6b, 0x21, 0x78, 0x8d, 0xc7, 0xe7, 0x21, 0xc3, 0x8f, 0x26, 0x3c, 0x36, 0x19, 0x82, 0x4d,
		0xca, 0x76, 0x17, 0x06, 0x93, 0xa8, 0x48, 0x4f, 0xf5, 0x49, 0x17, 0x61, 0x08, 0x89, 0x22, 0xc9,
		0xf0, 0x24, 0x9f, 0x80, 0xd3, 0x61, 0x43, 0x46, 0x08, 0xc7, 0x3c, 0xcf, 0x31, 0x8e, 0x6a, 0xc4,
		0xa0, 0xd8, 0x33, 0xdb, 0x52, 0xe1, 0x34, 0xf3, 0x12, 0x4c, 0x85, 0x0c, 0x1c, 0x21, 0xb4, 0x8b,
		0x62, 0x35, 0x96, 0xe5, 0x68, 0xf1, 0x20, 0xd0, 0xb0, 0x0f, 0xb7, 0x9d, 0x86, 0xed, 0xf1, 0x55,
		0xd9, 0xd7, 0xa7, 0x60, 0x9c, 0x0e, 0x4f, 0x5b, 0x9d, 0xba, 0xd5, 0xb1, 0xea, 0xfa, 0x9f, 0xe9,
		0x5f, 0x3b, 0x2d, 0xf5, 0x0e, 0x6a, 0x14, 0x75, 0x82, 0x12, 0xea, 0xa5, 0xbe, 0x25, 0xd4, 0xa5,
		0x68, 0xfa, 0xa8, 0x4a, 0xaa, 0xd4, 0x53, 0x49, 0x3d, 0xd1, 0x9f, 0xb4, 0x5f, 0x41, 0x55, 0xea,
		0x29, 0xa8, 0x06, 0x93, 0x84, 0xd6, 0x55, 0x6b, 0xbd, 0x75, 0xd5, 0x7c, 0x7f, 0x96, 0xfe, 0xe5,
		0xd5, 0x5a, 0x6f, 0x79, 0x15, 0xc1, 0x13, 0x5e, 0x65, 0xad, 0xf5, 0x56, 0x59, 0x03, 0x78, 0xfa,
		0x17, 0x5b, 0x6b, 0xbd, 0xc5, 0x56, 0x04, 0x4f, 0x78, 0xcd, 0xb5, 0x1e, 0x52, 0x73, 0x3d, 0xd9,
		0x9f, 0x68, 0x50, 0xe9, 0xb5, 0x11, 0x56, 0x7a, 0x2d, 0x0c, 0x50, 0x6a, 0x60, 0x05, 0xb6, 0x1e,
		0x52, 0x81, 0x45, 0x29, 0xd6, 0xa7, 0x10, 0xdb, 0x08, 0x2b, 0xc4, 0x22, 0x15, 0xeb, 0x57, 0x8f,
		0xfd, 0x82, 0x5c, 0x8f, 0x5d, 0xec, 0xcf, 0x14, 0x5e, 0x96, 0xad, 0xf5, 0x96, 0x65, 0xf3, 0x51,
		0x39, 0x17, 0x56, 0x9d, 0xbd, 0xd4, 0xb7, 0x3a, 0x1b, 0x22, 0x85, 0xa3, 0x8a, 0xb4, 0x17, 0xfb,
		0x15, 0x69, 0x8b, 0xd1, 0xdc, 0x83, 0x6b, 0xb5, 0xbd, 0x3e, 0xb5, 0xda, 0xd3, 0xd1, 0xc4, 0x3f,
		0x2f, 0xd9, 0x7e, 0x5e, 0xb2, 0xfd, 0xbc, 0x64, 0xfb, 0x79, 0xc9, 0xf6, 0xd3, 0x2f, 0xd9, 0xf2,
		0xf1, 0xcf, 0x7c, 0x69, 0x4e, 0xc9, 0xfd, 0x47, 0xd5, 0xff, 0x4b, 0x6b, 0x2f, 0x34, 0xbc, 0x23,
		0x34, 0xbc, 0x6d, 0x42, 0x06, 0xff, 0xf2, 0x6f, 0xcb, 0x6c, 0xb7, 0x1b, 0xf6, 0x21, 0xad, 0xd9,
		0x16, 0x7a, 0x97, 0x12, 0x29, 0x00, 0xff, 0x95, 0x99, 0x4d, 0x22, 0x4c, 0xa7, 0x1b, 0x3b, 0x68,
		0xd1, 0xef, 0x40, 0xba, 0xe5, 0x1e, 0xfa, 0x6c, 0xb1, 0x9e, 0x89, 0x50, 0x62, 0x23, 0x4f, 0x1a,
		0x90, 0x41, 0xcb, 0x6f, 0x40, 0xaa, 0xed, 0x1f, 0x7b, 0x81, 0x6a, 0x6a, 0x94, 0x6a, 0xc8, 0xa7,
		0xa2, 0x6a, 0xfb, 0x41, 0x0b, 0x0a, 0x5b, 0x59, 0xf7, 0xa8, 0x91, 0x4e, 0x08, 0x9e, 0x17, 0x60,
		0x42, 0xd2, 0x36, 0x24, 0xe7, 0x1f, 0xc0, 0x37, 0x48, 0x31, 0x59, 0xf3, 0xa8, 0x9c, 0xe0, 0x03,
		0x32, 0xf7, 0x28, 0x8c, 0x09, 0xdc, 0x7a, 0x06, 0x94, 0x03, 0xfa, 0x3d, 0x4a, 0xe5, 0x20, 0xf7,
		0x45, 0x05, 0xd2, 0xf4, 0x0c, 0xc1, 0xb6, 0xd9, 0xe8, 0xe8, 0xcf, 0x43, 0xbc, 0xc9, 0xbe, 0xcb,
		0xf4, 0xa0, 0xdf, 0x9b, 0xc5, 0x0c, 0xfa, 0x1a, 0x24, 0x3a, 0xfe, 0x77, 0x9d, 0x1e, 0xe8, 0xcb,
		0xb0, 0x18, 0x9e, 0xbb, 0xa7, 0xc0, 0x24, 0x3d, 0xe2, 0xea, 0xd2, 0x93, 0xcf, 0x66, 0x7b, 0xe6,
		0x6b, 0x0a, 0xa4, 0xfc, 0x2b, 0x7d, 0x1f, 0xc6, 0xfd, 0x0b, 0x72, 0xba, 0x9e, 0x44, 0x6a, 0x9e,
		0xb3, 0x70, 0x0f, 0xc7, 0x62, 0xc8, 0x27, 0xb2, 0x0b, 0x45, 0xe6, 0x64, 0xb1, 0x71, 0xa6, 0x00,
		0x53, 0x21, 0x62, 0x27, 0x99, 0x90, 0x73, 0xe7, 0x21, 0x55, 0x71, 0x3c, 0xf2, 0x93, 0x39, 0xfa,
		0x69, 0x6e, 0x57, 0xa1, 0x18, 0xd3, 0x4e, 0x61, 0xf0, 0xc2, 0x79, 0x18, 0xa5, 0xd9, 0xaf, 0x8f,
		0x40, 0x6c, 0xb3, 0xa0, 0x9d, 0xc2, 0xff, 0x17, 0x35, 0x05, 0xff, 0x5f, 0xd2, 0x62, 0xc5, 0x8d,
		0x0f, 0x72, 0x8b, 0x69, 0x7f, 0x84, 0x98, 0xe7, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff, 0xfc, 0x29,
		0xc0, 0x35, 0xbf, 0x83, 0x00, 0x00,
	}
	r := bytes.NewReader(gzipped)
	gzipr, err := compress_gzip.NewReader(r)
	if err != nil {
		panic(err)
	}
	ungzipped, err := io_ioutil.ReadAll(gzipr)
	if err != nil {
		panic(err)
	}
	if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil {
		panic(err)
	}
	return d
}
func (x MapEnum) String() string {
	s, ok := MapEnum_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Message_Humour) String() string {
	s, ok := Message_Humour_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Message) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Message)
	if !ok {
		that2, ok := that.(Message)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Message")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Message but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Message but is not nil && this == nil")
	}
	if this.Name != that1.Name {
		return fmt.Errorf("Name this(%v) Not Equal that(%v)", this.Name, that1.Name)
	}
	if this.Hilarity != that1.Hilarity {
		return fmt.Errorf("Hilarity this(%v) Not Equal that(%v)", this.Hilarity, that1.Hilarity)
	}
	if this.HeightInCm != that1.HeightInCm {
		return fmt.Errorf("HeightInCm this(%v) Not Equal that(%v)", this.HeightInCm, that1.HeightInCm)
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
	}
	if this.ResultCount != that1.ResultCount {
		return fmt.Errorf("ResultCount this(%v) Not Equal that(%v)", this.ResultCount, that1.ResultCount)
	}
	if this.TrueScotsman != that1.TrueScotsman {
		return fmt.Errorf("TrueScotsman this(%v) Not Equal that(%v)", this.TrueScotsman, that1.TrueScotsman)
	}
	if this.Score != that1.Score {
		return fmt.Errorf("Score this(%v) Not Equal that(%v)", this.Score, that1.Score)
	}
	if len(this.Key) != len(that1.Key) {
		return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key))
	}
	for i := range this.Key {
		if this.Key[i] != that1.Key[i] {
			return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i])
		}
	}
	if !this.Nested.Equal(that1.Nested) {
		return fmt.Errorf("Nested this(%v) Not Equal that(%v)", this.Nested, that1.Nested)
	}
	if len(this.Terrain) != len(that1.Terrain) {
		return fmt.Errorf("Terrain this(%v) Not Equal that(%v)", len(this.Terrain), len(that1.Terrain))
	}
	for i := range this.Terrain {
		if !this.Terrain[i].Equal(that1.Terrain[i]) {
			return fmt.Errorf("Terrain this[%v](%v) Not Equal that[%v](%v)", i, this.Terrain[i], i, that1.Terrain[i])
		}
	}
	if !this.Proto2Field.Equal(that1.Proto2Field) {
		return fmt.Errorf("Proto2Field this(%v) Not Equal that(%v)", this.Proto2Field, that1.Proto2Field)
	}
	if len(this.Proto2Value) != len(that1.Proto2Value) {
		return fmt.Errorf("Proto2Value this(%v) Not Equal that(%v)", len(this.Proto2Value), len(that1.Proto2Value))
	}
	for i := range this.Proto2Value {
		if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) {
			return fmt.Errorf("Proto2Value this[%v](%v) Not Equal that[%v](%v)", i, this.Proto2Value[i], i, that1.Proto2Value[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *Message) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Message)
	if !ok {
		that2, ok := that.(Message)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Hilarity != that1.Hilarity {
		return false
	}
	if this.HeightInCm != that1.HeightInCm {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if this.ResultCount != that1.ResultCount {
		return false
	}
	if this.TrueScotsman != that1.TrueScotsman {
		return false
	}
	if this.Score != that1.Score {
		return false
	}
	if len(this.Key) != len(that1.Key) {
		return false
	}
	for i := range this.Key {
		if this.Key[i] != that1.Key[i] {
			return false
		}
	}
	if !this.Nested.Equal(that1.Nested) {
		return false
	}
	if len(this.Terrain) != len(that1.Terrain) {
		return false
	}
	for i := range this.Terrain {
		if !this.Terrain[i].Equal(that1.Terrain[i]) {
			return false
		}
	}
	if !this.Proto2Field.Equal(that1.Proto2Field) {
		return false
	}
	if len(this.Proto2Value) != len(that1.Proto2Value) {
		return false
	}
	for i := range this.Proto2Value {
		if !this.Proto2Value[i].Equal(that1.Proto2Value[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Nested) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Nested)
	if !ok {
		that2, ok := that.(Nested)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Nested")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Nested but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Nested but is not nil && this == nil")
	}
	if this.Bunny != that1.Bunny {
		return fmt.Errorf("Bunny this(%v) Not Equal that(%v)", this.Bunny, that1.Bunny)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *Nested) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Nested)
	if !ok {
		that2, ok := that.(Nested)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Bunny != that1.Bunny {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *AllMaps) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*AllMaps)
	if !ok {
		that2, ok := that.(AllMaps)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *AllMaps")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *AllMaps but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *AllMaps but is not nil && this == nil")
	}
	if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
		return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
	}
	for i := range this.StringToDoubleMap {
		if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
			return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
		}
	}
	if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
		return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
	}
	for i := range this.StringToFloatMap {
		if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
			return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
		}
	}
	if len(this.Int32Map) != len(that1.Int32Map) {
		return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
	}
	for i := range this.Int32Map {
		if this.Int32Map[i] != that1.Int32Map[i] {
			return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
		}
	}
	if len(this.Int64Map) != len(that1.Int64Map) {
		return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
	}
	for i := range this.Int64Map {
		if this.Int64Map[i] != that1.Int64Map[i] {
			return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
		}
	}
	if len(this.Uint32Map) != len(that1.Uint32Map) {
		return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
	}
	for i := range this.Uint32Map {
		if this.Uint32Map[i] != that1.Uint32Map[i] {
			return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
		}
	}
	if len(this.Uint64Map) != len(that1.Uint64Map) {
		return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
	}
	for i := range this.Uint64Map {
		if this.Uint64Map[i] != that1.Uint64Map[i] {
			return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
		}
	}
	if len(this.Sint32Map) != len(that1.Sint32Map) {
		return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
	}
	for i := range this.Sint32Map {
		if this.Sint32Map[i] != that1.Sint32Map[i] {
			return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
		}
	}
	if len(this.Sint64Map) != len(that1.Sint64Map) {
		return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
	}
	for i := range this.Sint64Map {
		if this.Sint64Map[i] != that1.Sint64Map[i] {
			return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
		}
	}
	if len(this.Fixed32Map) != len(that1.Fixed32Map) {
		return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
	}
	for i := range this.Fixed32Map {
		if this.Fixed32Map[i] != that1.Fixed32Map[i] {
			return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
		}
	}
	if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
		return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
	}
	for i := range this.Sfixed32Map {
		if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
			return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
		}
	}
	if len(this.Fixed64Map) != len(that1.Fixed64Map) {
		return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
	}
	for i := range this.Fixed64Map {
		if this.Fixed64Map[i] != that1.Fixed64Map[i] {
			return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
		}
	}
	if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
		return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
	}
	for i := range this.Sfixed64Map {
		if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
			return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
		}
	}
	if len(this.BoolMap) != len(that1.BoolMap) {
		return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
	}
	for i := range this.BoolMap {
		if this.BoolMap[i] != that1.BoolMap[i] {
			return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
		}
	}
	if len(this.StringMap) != len(that1.StringMap) {
		return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
	}
	for i := range this.StringMap {
		if this.StringMap[i] != that1.StringMap[i] {
			return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
		}
	}
	if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
		return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
	}
	for i := range this.StringToBytesMap {
		if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
			return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
		}
	}
	if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
		return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
	}
	for i := range this.StringToEnumMap {
		if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
			return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
		}
	}
	if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
		return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
	}
	for i := range this.StringToMsgMap {
		if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
			return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *AllMaps) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AllMaps)
	if !ok {
		that2, ok := that.(AllMaps)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
		return false
	}
	for i := range this.StringToDoubleMap {
		if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
			return false
		}
	}
	if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
		return false
	}
	for i := range this.StringToFloatMap {
		if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
			return false
		}
	}
	if len(this.Int32Map) != len(that1.Int32Map) {
		return false
	}
	for i := range this.Int32Map {
		if this.Int32Map[i] != that1.Int32Map[i] {
			return false
		}
	}
	if len(this.Int64Map) != len(that1.Int64Map) {
		return false
	}
	for i := range this.Int64Map {
		if this.Int64Map[i] != that1.Int64Map[i] {
			return false
		}
	}
	if len(this.Uint32Map) != len(that1.Uint32Map) {
		return false
	}
	for i := range this.Uint32Map {
		if this.Uint32Map[i] != that1.Uint32Map[i] {
			return false
		}
	}
	if len(this.Uint64Map) != len(that1.Uint64Map) {
		return false
	}
	for i := range this.Uint64Map {
		if this.Uint64Map[i] != that1.Uint64Map[i] {
			return false
		}
	}
	if len(this.Sint32Map) != len(that1.Sint32Map) {
		return false
	}
	for i := range this.Sint32Map {
		if this.Sint32Map[i] != that1.Sint32Map[i] {
			return false
		}
	}
	if len(this.Sint64Map) != len(that1.Sint64Map) {
		return false
	}
	for i := range this.Sint64Map {
		if this.Sint64Map[i] != that1.Sint64Map[i] {
			return false
		}
	}
	if len(this.Fixed32Map) != len(that1.Fixed32Map) {
		return false
	}
	for i := range this.Fixed32Map {
		if this.Fixed32Map[i] != that1.Fixed32Map[i] {
			return false
		}
	}
	if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
		return false
	}
	for i := range this.Sfixed32Map {
		if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
			return false
		}
	}
	if len(this.Fixed64Map) != len(that1.Fixed64Map) {
		return false
	}
	for i := range this.Fixed64Map {
		if this.Fixed64Map[i] != that1.Fixed64Map[i] {
			return false
		}
	}
	if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
		return false
	}
	for i := range this.Sfixed64Map {
		if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
			return false
		}
	}
	if len(this.BoolMap) != len(that1.BoolMap) {
		return false
	}
	for i := range this.BoolMap {
		if this.BoolMap[i] != that1.BoolMap[i] {
			return false
		}
	}
	if len(this.StringMap) != len(that1.StringMap) {
		return false
	}
	for i := range this.StringMap {
		if this.StringMap[i] != that1.StringMap[i] {
			return false
		}
	}
	if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
		return false
	}
	for i := range this.StringToBytesMap {
		if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
			return false
		}
	}
	if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
		return false
	}
	for i := range this.StringToEnumMap {
		if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
			return false
		}
	}
	if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
		return false
	}
	for i := range this.StringToMsgMap {
		if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *AllMapsOrdered) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*AllMapsOrdered)
	if !ok {
		that2, ok := that.(AllMapsOrdered)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *AllMapsOrdered")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *AllMapsOrdered but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *AllMapsOrdered but is not nil && this == nil")
	}
	if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
		return fmt.Errorf("StringToDoubleMap this(%v) Not Equal that(%v)", len(this.StringToDoubleMap), len(that1.StringToDoubleMap))
	}
	for i := range this.StringToDoubleMap {
		if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
			return fmt.Errorf("StringToDoubleMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToDoubleMap[i], i, that1.StringToDoubleMap[i])
		}
	}
	if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
		return fmt.Errorf("StringToFloatMap this(%v) Not Equal that(%v)", len(this.StringToFloatMap), len(that1.StringToFloatMap))
	}
	for i := range this.StringToFloatMap {
		if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
			return fmt.Errorf("StringToFloatMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToFloatMap[i], i, that1.StringToFloatMap[i])
		}
	}
	if len(this.Int32Map) != len(that1.Int32Map) {
		return fmt.Errorf("Int32Map this(%v) Not Equal that(%v)", len(this.Int32Map), len(that1.Int32Map))
	}
	for i := range this.Int32Map {
		if this.Int32Map[i] != that1.Int32Map[i] {
			return fmt.Errorf("Int32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int32Map[i], i, that1.Int32Map[i])
		}
	}
	if len(this.Int64Map) != len(that1.Int64Map) {
		return fmt.Errorf("Int64Map this(%v) Not Equal that(%v)", len(this.Int64Map), len(that1.Int64Map))
	}
	for i := range this.Int64Map {
		if this.Int64Map[i] != that1.Int64Map[i] {
			return fmt.Errorf("Int64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Int64Map[i], i, that1.Int64Map[i])
		}
	}
	if len(this.Uint32Map) != len(that1.Uint32Map) {
		return fmt.Errorf("Uint32Map this(%v) Not Equal that(%v)", len(this.Uint32Map), len(that1.Uint32Map))
	}
	for i := range this.Uint32Map {
		if this.Uint32Map[i] != that1.Uint32Map[i] {
			return fmt.Errorf("Uint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint32Map[i], i, that1.Uint32Map[i])
		}
	}
	if len(this.Uint64Map) != len(that1.Uint64Map) {
		return fmt.Errorf("Uint64Map this(%v) Not Equal that(%v)", len(this.Uint64Map), len(that1.Uint64Map))
	}
	for i := range this.Uint64Map {
		if this.Uint64Map[i] != that1.Uint64Map[i] {
			return fmt.Errorf("Uint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Uint64Map[i], i, that1.Uint64Map[i])
		}
	}
	if len(this.Sint32Map) != len(that1.Sint32Map) {
		return fmt.Errorf("Sint32Map this(%v) Not Equal that(%v)", len(this.Sint32Map), len(that1.Sint32Map))
	}
	for i := range this.Sint32Map {
		if this.Sint32Map[i] != that1.Sint32Map[i] {
			return fmt.Errorf("Sint32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint32Map[i], i, that1.Sint32Map[i])
		}
	}
	if len(this.Sint64Map) != len(that1.Sint64Map) {
		return fmt.Errorf("Sint64Map this(%v) Not Equal that(%v)", len(this.Sint64Map), len(that1.Sint64Map))
	}
	for i := range this.Sint64Map {
		if this.Sint64Map[i] != that1.Sint64Map[i] {
			return fmt.Errorf("Sint64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sint64Map[i], i, that1.Sint64Map[i])
		}
	}
	if len(this.Fixed32Map) != len(that1.Fixed32Map) {
		return fmt.Errorf("Fixed32Map this(%v) Not Equal that(%v)", len(this.Fixed32Map), len(that1.Fixed32Map))
	}
	for i := range this.Fixed32Map {
		if this.Fixed32Map[i] != that1.Fixed32Map[i] {
			return fmt.Errorf("Fixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed32Map[i], i, that1.Fixed32Map[i])
		}
	}
	if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
		return fmt.Errorf("Sfixed32Map this(%v) Not Equal that(%v)", len(this.Sfixed32Map), len(that1.Sfixed32Map))
	}
	for i := range this.Sfixed32Map {
		if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
			return fmt.Errorf("Sfixed32Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed32Map[i], i, that1.Sfixed32Map[i])
		}
	}
	if len(this.Fixed64Map) != len(that1.Fixed64Map) {
		return fmt.Errorf("Fixed64Map this(%v) Not Equal that(%v)", len(this.Fixed64Map), len(that1.Fixed64Map))
	}
	for i := range this.Fixed64Map {
		if this.Fixed64Map[i] != that1.Fixed64Map[i] {
			return fmt.Errorf("Fixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Fixed64Map[i], i, that1.Fixed64Map[i])
		}
	}
	if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
		return fmt.Errorf("Sfixed64Map this(%v) Not Equal that(%v)", len(this.Sfixed64Map), len(that1.Sfixed64Map))
	}
	for i := range this.Sfixed64Map {
		if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
			return fmt.Errorf("Sfixed64Map this[%v](%v) Not Equal that[%v](%v)", i, this.Sfixed64Map[i], i, that1.Sfixed64Map[i])
		}
	}
	if len(this.BoolMap) != len(that1.BoolMap) {
		return fmt.Errorf("BoolMap this(%v) Not Equal that(%v)", len(this.BoolMap), len(that1.BoolMap))
	}
	for i := range this.BoolMap {
		if this.BoolMap[i] != that1.BoolMap[i] {
			return fmt.Errorf("BoolMap this[%v](%v) Not Equal that[%v](%v)", i, this.BoolMap[i], i, that1.BoolMap[i])
		}
	}
	if len(this.StringMap) != len(that1.StringMap) {
		return fmt.Errorf("StringMap this(%v) Not Equal that(%v)", len(this.StringMap), len(that1.StringMap))
	}
	for i := range this.StringMap {
		if this.StringMap[i] != that1.StringMap[i] {
			return fmt.Errorf("StringMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringMap[i], i, that1.StringMap[i])
		}
	}
	if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
		return fmt.Errorf("StringToBytesMap this(%v) Not Equal that(%v)", len(this.StringToBytesMap), len(that1.StringToBytesMap))
	}
	for i := range this.StringToBytesMap {
		if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
			return fmt.Errorf("StringToBytesMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToBytesMap[i], i, that1.StringToBytesMap[i])
		}
	}
	if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
		return fmt.Errorf("StringToEnumMap this(%v) Not Equal that(%v)", len(this.StringToEnumMap), len(that1.StringToEnumMap))
	}
	for i := range this.StringToEnumMap {
		if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
			return fmt.Errorf("StringToEnumMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToEnumMap[i], i, that1.StringToEnumMap[i])
		}
	}
	if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
		return fmt.Errorf("StringToMsgMap this(%v) Not Equal that(%v)", len(this.StringToMsgMap), len(that1.StringToMsgMap))
	}
	for i := range this.StringToMsgMap {
		if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
			return fmt.Errorf("StringToMsgMap this[%v](%v) Not Equal that[%v](%v)", i, this.StringToMsgMap[i], i, that1.StringToMsgMap[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *AllMapsOrdered) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AllMapsOrdered)
	if !ok {
		that2, ok := that.(AllMapsOrdered)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.StringToDoubleMap) != len(that1.StringToDoubleMap) {
		return false
	}
	for i := range this.StringToDoubleMap {
		if this.StringToDoubleMap[i] != that1.StringToDoubleMap[i] {
			return false
		}
	}
	if len(this.StringToFloatMap) != len(that1.StringToFloatMap) {
		return false
	}
	for i := range this.StringToFloatMap {
		if this.StringToFloatMap[i] != that1.StringToFloatMap[i] {
			return false
		}
	}
	if len(this.Int32Map) != len(that1.Int32Map) {
		return false
	}
	for i := range this.Int32Map {
		if this.Int32Map[i] != that1.Int32Map[i] {
			return false
		}
	}
	if len(this.Int64Map) != len(that1.Int64Map) {
		return false
	}
	for i := range this.Int64Map {
		if this.Int64Map[i] != that1.Int64Map[i] {
			return false
		}
	}
	if len(this.Uint32Map) != len(that1.Uint32Map) {
		return false
	}
	for i := range this.Uint32Map {
		if this.Uint32Map[i] != that1.Uint32Map[i] {
			return false
		}
	}
	if len(this.Uint64Map) != len(that1.Uint64Map) {
		return false
	}
	for i := range this.Uint64Map {
		if this.Uint64Map[i] != that1.Uint64Map[i] {
			return false
		}
	}
	if len(this.Sint32Map) != len(that1.Sint32Map) {
		return false
	}
	for i := range this.Sint32Map {
		if this.Sint32Map[i] != that1.Sint32Map[i] {
			return false
		}
	}
	if len(this.Sint64Map) != len(that1.Sint64Map) {
		return false
	}
	for i := range this.Sint64Map {
		if this.Sint64Map[i] != that1.Sint64Map[i] {
			return false
		}
	}
	if len(this.Fixed32Map) != len(that1.Fixed32Map) {
		return false
	}
	for i := range this.Fixed32Map {
		if this.Fixed32Map[i] != that1.Fixed32Map[i] {
			return false
		}
	}
	if len(this.Sfixed32Map) != len(that1.Sfixed32Map) {
		return false
	}
	for i := range this.Sfixed32Map {
		if this.Sfixed32Map[i] != that1.Sfixed32Map[i] {
			return false
		}
	}
	if len(this.Fixed64Map) != len(that1.Fixed64Map) {
		return false
	}
	for i := range this.Fixed64Map {
		if this.Fixed64Map[i] != that1.Fixed64Map[i] {
			return false
		}
	}
	if len(this.Sfixed64Map) != len(that1.Sfixed64Map) {
		return false
	}
	for i := range this.Sfixed64Map {
		if this.Sfixed64Map[i] != that1.Sfixed64Map[i] {
			return false
		}
	}
	if len(this.BoolMap) != len(that1.BoolMap) {
		return false
	}
	for i := range this.BoolMap {
		if this.BoolMap[i] != that1.BoolMap[i] {
			return false
		}
	}
	if len(this.StringMap) != len(that1.StringMap) {
		return false
	}
	for i := range this.StringMap {
		if this.StringMap[i] != that1.StringMap[i] {
			return false
		}
	}
	if len(this.StringToBytesMap) != len(that1.StringToBytesMap) {
		return false
	}
	for i := range this.StringToBytesMap {
		if !bytes.Equal(this.StringToBytesMap[i], that1.StringToBytesMap[i]) {
			return false
		}
	}
	if len(this.StringToEnumMap) != len(that1.StringToEnumMap) {
		return false
	}
	for i := range this.StringToEnumMap {
		if this.StringToEnumMap[i] != that1.StringToEnumMap[i] {
			return false
		}
	}
	if len(this.StringToMsgMap) != len(that1.StringToMsgMap) {
		return false
	}
	for i := range this.StringToMsgMap {
		if !this.StringToMsgMap[i].Equal(that1.StringToMsgMap[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *MessageWithMap) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*MessageWithMap)
	if !ok {
		that2, ok := that.(MessageWithMap)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *MessageWithMap")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *MessageWithMap but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *MessageWithMap but is not nil && this == nil")
	}
	if len(this.NameMapping) != len(that1.NameMapping) {
		return fmt.Errorf("NameMapping this(%v) Not Equal that(%v)", len(this.NameMapping), len(that1.NameMapping))
	}
	for i := range this.NameMapping {
		if this.NameMapping[i] != that1.NameMapping[i] {
			return fmt.Errorf("NameMapping this[%v](%v) Not Equal that[%v](%v)", i, this.NameMapping[i], i, that1.NameMapping[i])
		}
	}
	if len(this.MsgMapping) != len(that1.MsgMapping) {
		return fmt.Errorf("MsgMapping this(%v) Not Equal that(%v)", len(this.MsgMapping), len(that1.MsgMapping))
	}
	for i := range this.MsgMapping {
		if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) {
			return fmt.Errorf("MsgMapping this[%v](%v) Not Equal that[%v](%v)", i, this.MsgMapping[i], i, that1.MsgMapping[i])
		}
	}
	if len(this.ByteMapping) != len(that1.ByteMapping) {
		return fmt.Errorf("ByteMapping this(%v) Not Equal that(%v)", len(this.ByteMapping), len(that1.ByteMapping))
	}
	for i := range this.ByteMapping {
		if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) {
			return fmt.Errorf("ByteMapping this[%v](%v) Not Equal that[%v](%v)", i, this.ByteMapping[i], i, that1.ByteMapping[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *MessageWithMap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MessageWithMap)
	if !ok {
		that2, ok := that.(MessageWithMap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NameMapping) != len(that1.NameMapping) {
		return false
	}
	for i := range this.NameMapping {
		if this.NameMapping[i] != that1.NameMapping[i] {
			return false
		}
	}
	if len(this.MsgMapping) != len(that1.MsgMapping) {
		return false
	}
	for i := range this.MsgMapping {
		if !this.MsgMapping[i].Equal(that1.MsgMapping[i]) {
			return false
		}
	}
	if len(this.ByteMapping) != len(that1.ByteMapping) {
		return false
	}
	for i := range this.ByteMapping {
		if !bytes.Equal(this.ByteMapping[i], that1.ByteMapping[i]) {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *FloatingPoint) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*FloatingPoint)
	if !ok {
		that2, ok := that.(FloatingPoint)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *FloatingPoint")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *FloatingPoint but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *FloatingPoint but is not nil && this == nil")
	}
	if this.F != that1.F {
		return fmt.Errorf("F this(%v) Not Equal that(%v)", this.F, that1.F)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *FloatingPoint) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FloatingPoint)
	if !ok {
		that2, ok := that.(FloatingPoint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.F != that1.F {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *Uint128Pair) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Uint128Pair)
	if !ok {
		that2, ok := that.(Uint128Pair)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Uint128Pair")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Uint128Pair but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Uint128Pair but is not nil && this == nil")
	}
	if !this.Left.Equal(that1.Left) {
		return fmt.Errorf("Left this(%v) Not Equal that(%v)", this.Left, that1.Left)
	}
	if that1.Right == nil {
		if this.Right != nil {
			return fmt.Errorf("this.Right != nil && that1.Right == nil")
		}
	} else if !this.Right.Equal(*that1.Right) {
		return fmt.Errorf("Right this(%v) Not Equal that(%v)", this.Right, that1.Right)
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *Uint128Pair) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Uint128Pair)
	if !ok {
		that2, ok := that.(Uint128Pair)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Left.Equal(that1.Left) {
		return false
	}
	if that1.Right == nil {
		if this.Right != nil {
			return false
		}
	} else if !this.Right.Equal(*that1.Right) {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *ContainsNestedMap) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ContainsNestedMap)
	if !ok {
		that2, ok := that.(ContainsNestedMap)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *ContainsNestedMap")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ContainsNestedMap but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ContainsNestedMap but is not nil && this == nil")
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *ContainsNestedMap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ContainsNestedMap)
	if !ok {
		that2, ok := that.(ContainsNestedMap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *ContainsNestedMap_NestedMap) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ContainsNestedMap_NestedMap)
	if !ok {
		that2, ok := that.(ContainsNestedMap_NestedMap)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *ContainsNestedMap_NestedMap")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ContainsNestedMap_NestedMap but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ContainsNestedMap_NestedMap but is not nil && this == nil")
	}
	if len(this.NestedMapField) != len(that1.NestedMapField) {
		return fmt.Errorf("NestedMapField this(%v) Not Equal that(%v)", len(this.NestedMapField), len(that1.NestedMapField))
	}
	for i := range this.NestedMapField {
		if this.NestedMapField[i] != that1.NestedMapField[i] {
			return fmt.Errorf("NestedMapField this[%v](%v) Not Equal that[%v](%v)", i, this.NestedMapField[i], i, that1.NestedMapField[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *ContainsNestedMap_NestedMap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ContainsNestedMap_NestedMap)
	if !ok {
		that2, ok := that.(ContainsNestedMap_NestedMap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.NestedMapField) != len(that1.NestedMapField) {
		return false
	}
	for i := range this.NestedMapField {
		if this.NestedMapField[i] != that1.NestedMapField[i] {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}
func (this *NotPacked) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*NotPacked)
	if !ok {
		that2, ok := that.(NotPacked)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *NotPacked")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *NotPacked but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *NotPacked but is not nil && this == nil")
	}
	if len(this.Key) != len(that1.Key) {
		return fmt.Errorf("Key this(%v) Not Equal that(%v)", len(this.Key), len(that1.Key))
	}
	for i := range this.Key {
		if this.Key[i] != that1.Key[i] {
			return fmt.Errorf("Key this[%v](%v) Not Equal that[%v](%v)", i, this.Key[i], i, that1.Key[i])
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return fmt.Errorf("XXX_unrecognized this(%v) Not Equal that(%v)", this.XXX_unrecognized, that1.XXX_unrecognized)
	}
	return nil
}
func (this *NotPacked) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NotPacked)
	if !ok {
		that2, ok := that.(NotPacked)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Key) != len(that1.Key) {
		return false
	}
	for i := range this.Key {
		if this.Key[i] != that1.Key[i] {
			return false
		}
	}
	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
		return false
	}
	return true
}

type MessageFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetName() string
	GetHilarity() Message_Humour
	GetHeightInCm() uint32
	GetData() []byte
	GetResultCount() int64
	GetTrueScotsman() bool
	GetScore() float32
	GetKey() []uint64
	GetNested() *Nested
	GetTerrain() map[int64]*Nested
	GetProto2Field() *both.NinOptNative
	GetProto2Value() map[int64]*both.NinOptEnum
}

func (this *Message) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *Message) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewMessageFromFace(this)
}

func (this *Message) GetName() string {
	return this.Name
}

func (this *Message) GetHilarity() Message_Humour {
	return this.Hilarity
}

func (this *Message) GetHeightInCm() uint32 {
	return this.HeightInCm
}

func (this *Message) GetData() []byte {
	return this.Data
}

func (this *Message) GetResultCount() int64 {
	return this.ResultCount
}

func (this *Message) GetTrueScotsman() bool {
	return this.TrueScotsman
}

func (this *Message) GetScore() float32 {
	return this.Score
}

func (this *Message) GetKey() []uint64 {
	return this.Key
}

func (this *Message) GetNested() *Nested {
	return this.Nested
}

func (this *Message) GetTerrain() map[int64]*Nested {
	return this.Terrain
}

func (this *Message) GetProto2Field() *both.NinOptNative {
	return this.Proto2Field
}

func (this *Message) GetProto2Value() map[int64]*both.NinOptEnum {
	return this.Proto2Value
}

func NewMessageFromFace(that MessageFace) *Message {
	this := &Message{}
	this.Name = that.GetName()
	this.Hilarity = that.GetHilarity()
	this.HeightInCm = that.GetHeightInCm()
	this.Data = that.GetData()
	this.ResultCount = that.GetResultCount()
	this.TrueScotsman = that.GetTrueScotsman()
	this.Score = that.GetScore()
	this.Key = that.GetKey()
	this.Nested = that.GetNested()
	this.Terrain = that.GetTerrain()
	this.Proto2Field = that.GetProto2Field()
	this.Proto2Value = that.GetProto2Value()
	return this
}

type NestedFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetBunny() string
}

func (this *Nested) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *Nested) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewNestedFromFace(this)
}

func (this *Nested) GetBunny() string {
	return this.Bunny
}

func NewNestedFromFace(that NestedFace) *Nested {
	this := &Nested{}
	this.Bunny = that.GetBunny()
	return this
}

type AllMapsFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetStringToDoubleMap() map[string]float64
	GetStringToFloatMap() map[string]float32
	GetInt32Map() map[int32]int32
	GetInt64Map() map[int64]int64
	GetUint32Map() map[uint32]uint32
	GetUint64Map() map[uint64]uint64
	GetSint32Map() map[int32]int32
	GetSint64Map() map[int64]int64
	GetFixed32Map() map[uint32]uint32
	GetSfixed32Map() map[int32]int32
	GetFixed64Map() map[uint64]uint64
	GetSfixed64Map() map[int64]int64
	GetBoolMap() map[bool]bool
	GetStringMap() map[string]string
	GetStringToBytesMap() map[string][]byte
	GetStringToEnumMap() map[string]MapEnum
	GetStringToMsgMap() map[string]*FloatingPoint
}

func (this *AllMaps) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *AllMaps) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewAllMapsFromFace(this)
}

func (this *AllMaps) GetStringToDoubleMap() map[string]float64 {
	return this.StringToDoubleMap
}

func (this *AllMaps) GetStringToFloatMap() map[string]float32 {
	return this.StringToFloatMap
}

func (this *AllMaps) GetInt32Map() map[int32]int32 {
	return this.Int32Map
}

func (this *AllMaps) GetInt64Map() map[int64]int64 {
	return this.Int64Map
}

func (this *AllMaps) GetUint32Map() map[uint32]uint32 {
	return this.Uint32Map
}

func (this *AllMaps) GetUint64Map() map[uint64]uint64 {
	return this.Uint64Map
}

func (this *AllMaps) GetSint32Map() map[int32]int32 {
	return this.Sint32Map
}

func (this *AllMaps) GetSint64Map() map[int64]int64 {
	return this.Sint64Map
}

func (this *AllMaps) GetFixed32Map() map[uint32]uint32 {
	return this.Fixed32Map
}

func (this *AllMaps) GetSfixed32Map() map[int32]int32 {
	return this.Sfixed32Map
}

func (this *AllMaps) GetFixed64Map() map[uint64]uint64 {
	return this.Fixed64Map
}

func (this *AllMaps) GetSfixed64Map() map[int64]int64 {
	return this.Sfixed64Map
}

func (this *AllMaps) GetBoolMap() map[bool]bool {
	return this.BoolMap
}

func (this *AllMaps) GetStringMap() map[string]string {
	return this.StringMap
}

func (this *AllMaps) GetStringToBytesMap() map[string][]byte {
	return this.StringToBytesMap
}

func (this *AllMaps) GetStringToEnumMap() map[string]MapEnum {
	return this.StringToEnumMap
}

func (this *AllMaps) GetStringToMsgMap() map[string]*FloatingPoint {
	return this.StringToMsgMap
}

func NewAllMapsFromFace(that AllMapsFace) *AllMaps {
	this := &AllMaps{}
	this.StringToDoubleMap = that.GetStringToDoubleMap()
	this.StringToFloatMap = that.GetStringToFloatMap()
	this.Int32Map = that.GetInt32Map()
	this.Int64Map = that.GetInt64Map()
	this.Uint32Map = that.GetUint32Map()
	this.Uint64Map = that.GetUint64Map()
	this.Sint32Map = that.GetSint32Map()
	this.Sint64Map = that.GetSint64Map()
	this.Fixed32Map = that.GetFixed32Map()
	this.Sfixed32Map = that.GetSfixed32Map()
	this.Fixed64Map = that.GetFixed64Map()
	this.Sfixed64Map = that.GetSfixed64Map()
	this.BoolMap = that.GetBoolMap()
	this.StringMap = that.GetStringMap()
	this.StringToBytesMap = that.GetStringToBytesMap()
	this.StringToEnumMap = that.GetStringToEnumMap()
	this.StringToMsgMap = that.GetStringToMsgMap()
	return this
}

type AllMapsOrderedFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetStringToDoubleMap() map[string]float64
	GetStringToFloatMap() map[string]float32
	GetInt32Map() map[int32]int32
	GetInt64Map() map[int64]int64
	GetUint32Map() map[uint32]uint32
	GetUint64Map() map[uint64]uint64
	GetSint32Map() map[int32]int32
	GetSint64Map() map[int64]int64
	GetFixed32Map() map[uint32]uint32
	GetSfixed32Map() map[int32]int32
	GetFixed64Map() map[uint64]uint64
	GetSfixed64Map() map[int64]int64
	GetBoolMap() map[bool]bool
	GetStringMap() map[string]string
	GetStringToBytesMap() map[string][]byte
	GetStringToEnumMap() map[string]MapEnum
	GetStringToMsgMap() map[string]*FloatingPoint
}

func (this *AllMapsOrdered) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *AllMapsOrdered) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewAllMapsOrderedFromFace(this)
}

func (this *AllMapsOrdered) GetStringToDoubleMap() map[string]float64 {
	return this.StringToDoubleMap
}

func (this *AllMapsOrdered) GetStringToFloatMap() map[string]float32 {
	return this.StringToFloatMap
}

func (this *AllMapsOrdered) GetInt32Map() map[int32]int32 {
	return this.Int32Map
}

func (this *AllMapsOrdered) GetInt64Map() map[int64]int64 {
	return this.Int64Map
}

func (this *AllMapsOrdered) GetUint32Map() map[uint32]uint32 {
	return this.Uint32Map
}

func (this *AllMapsOrdered) GetUint64Map() map[uint64]uint64 {
	return this.Uint64Map
}

func (this *AllMapsOrdered) GetSint32Map() map[int32]int32 {
	return this.Sint32Map
}

func (this *AllMapsOrdered) GetSint64Map() map[int64]int64 {
	return this.Sint64Map
}

func (this *AllMapsOrdered) GetFixed32Map() map[uint32]uint32 {
	return this.Fixed32Map
}

func (this *AllMapsOrdered) GetSfixed32Map() map[int32]int32 {
	return this.Sfixed32Map
}

func (this *AllMapsOrdered) GetFixed64Map() map[uint64]uint64 {
	return this.Fixed64Map
}

func (this *AllMapsOrdered) GetSfixed64Map() map[int64]int64 {
	return this.Sfixed64Map
}

func (this *AllMapsOrdered) GetBoolMap() map[bool]bool {
	return this.BoolMap
}

func (this *AllMapsOrdered) GetStringMap() map[string]string {
	return this.StringMap
}

func (this *AllMapsOrdered) GetStringToBytesMap() map[string][]byte {
	return this.StringToBytesMap
}

func (this *AllMapsOrdered) GetStringToEnumMap() map[string]MapEnum {
	return this.StringToEnumMap
}

func (this *AllMapsOrdered) GetStringToMsgMap() map[string]*FloatingPoint {
	return this.StringToMsgMap
}

func NewAllMapsOrderedFromFace(that AllMapsOrderedFace) *AllMapsOrdered {
	this := &AllMapsOrdered{}
	this.StringToDoubleMap = that.GetStringToDoubleMap()
	this.StringToFloatMap = that.GetStringToFloatMap()
	this.Int32Map = that.GetInt32Map()
	this.Int64Map = that.GetInt64Map()
	this.Uint32Map = that.GetUint32Map()
	this.Uint64Map = that.GetUint64Map()
	this.Sint32Map = that.GetSint32Map()
	this.Sint64Map = that.GetSint64Map()
	this.Fixed32Map = that.GetFixed32Map()
	this.Sfixed32Map = that.GetSfixed32Map()
	this.Fixed64Map = that.GetFixed64Map()
	this.Sfixed64Map = that.GetSfixed64Map()
	this.BoolMap = that.GetBoolMap()
	this.StringMap = that.GetStringMap()
	this.StringToBytesMap = that.GetStringToBytesMap()
	this.StringToEnumMap = that.GetStringToEnumMap()
	this.StringToMsgMap = that.GetStringToMsgMap()
	return this
}

type MessageWithMapFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetNameMapping() map[int32]string
	GetMsgMapping() map[int64]*FloatingPoint
	GetByteMapping() map[bool][]byte
}

func (this *MessageWithMap) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *MessageWithMap) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewMessageWithMapFromFace(this)
}

func (this *MessageWithMap) GetNameMapping() map[int32]string {
	return this.NameMapping
}

func (this *MessageWithMap) GetMsgMapping() map[int64]*FloatingPoint {
	return this.MsgMapping
}

func (this *MessageWithMap) GetByteMapping() map[bool][]byte {
	return this.ByteMapping
}

func NewMessageWithMapFromFace(that MessageWithMapFace) *MessageWithMap {
	this := &MessageWithMap{}
	this.NameMapping = that.GetNameMapping()
	this.MsgMapping = that.GetMsgMapping()
	this.ByteMapping = that.GetByteMapping()
	return this
}

type FloatingPointFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetF() float64
}

func (this *FloatingPoint) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *FloatingPoint) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewFloatingPointFromFace(this)
}

func (this *FloatingPoint) GetF() float64 {
	return this.F
}

func NewFloatingPointFromFace(that FloatingPointFace) *FloatingPoint {
	this := &FloatingPoint{}
	this.F = that.GetF()
	return this
}

type Uint128PairFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetLeft() github_com_gogo_protobuf_test_custom.Uint128
	GetRight() *github_com_gogo_protobuf_test_custom.Uint128
}

func (this *Uint128Pair) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *Uint128Pair) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewUint128PairFromFace(this)
}

func (this *Uint128Pair) GetLeft() github_com_gogo_protobuf_test_custom.Uint128 {
	return this.Left
}

func (this *Uint128Pair) GetRight() *github_com_gogo_protobuf_test_custom.Uint128 {
	return this.Right
}

func NewUint128PairFromFace(that Uint128PairFace) *Uint128Pair {
	this := &Uint128Pair{}
	this.Left = that.GetLeft()
	this.Right = that.GetRight()
	return this
}

type ContainsNestedMapFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
}

func (this *ContainsNestedMap) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *ContainsNestedMap) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewContainsNestedMapFromFace(this)
}

func NewContainsNestedMapFromFace(that ContainsNestedMapFace) *ContainsNestedMap {
	this := &ContainsNestedMap{}
	return this
}

type ContainsNestedMap_NestedMapFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetNestedMapField() map[string]float64
}

func (this *ContainsNestedMap_NestedMap) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *ContainsNestedMap_NestedMap) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewContainsNestedMap_NestedMapFromFace(this)
}

func (this *ContainsNestedMap_NestedMap) GetNestedMapField() map[string]float64 {
	return this.NestedMapField
}

func NewContainsNestedMap_NestedMapFromFace(that ContainsNestedMap_NestedMapFace) *ContainsNestedMap_NestedMap {
	this := &ContainsNestedMap_NestedMap{}
	this.NestedMapField = that.GetNestedMapField()
	return this
}

type NotPackedFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
	GetKey() []uint64
}

func (this *NotPacked) Proto() github_com_gogo_protobuf_proto.Message {
	return this
}

func (this *NotPacked) TestProto() github_com_gogo_protobuf_proto.Message {
	return NewNotPackedFromFace(this)
}

func (this *NotPacked) GetKey() []uint64 {
	return this.Key
}

func NewNotPackedFromFace(that NotPackedFace) *NotPacked {
	this := &NotPacked{}
	this.Key = that.GetKey()
	return this
}

func (this *Message) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 16)
	s = append(s, "&theproto3.Message{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Hilarity: "+fmt.Sprintf("%#v", this.Hilarity)+",\n")
	s = append(s, "HeightInCm: "+fmt.Sprintf("%#v", this.HeightInCm)+",\n")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "ResultCount: "+fmt.Sprintf("%#v", this.ResultCount)+",\n")
	s = append(s, "TrueScotsman: "+fmt.Sprintf("%#v", this.TrueScotsman)+",\n")
	s = append(s, "Score: "+fmt.Sprintf("%#v", this.Score)+",\n")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	if this.Nested != nil {
		s = append(s, "Nested: "+fmt.Sprintf("%#v", this.Nested)+",\n")
	}
	keysForTerrain := make([]int64, 0, len(this.Terrain))
	for k := range this.Terrain {
		keysForTerrain = append(keysForTerrain, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain)
	mapStringForTerrain := "map[int64]*Nested{"
	for _, k := range keysForTerrain {
		mapStringForTerrain += fmt.Sprintf("%#v: %#v,", k, this.Terrain[k])
	}
	mapStringForTerrain += "}"
	if this.Terrain != nil {
		s = append(s, "Terrain: "+mapStringForTerrain+",\n")
	}
	if this.Proto2Field != nil {
		s = append(s, "Proto2Field: "+fmt.Sprintf("%#v", this.Proto2Field)+",\n")
	}
	keysForProto2Value := make([]int64, 0, len(this.Proto2Value))
	for k := range this.Proto2Value {
		keysForProto2Value = append(keysForProto2Value, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value)
	mapStringForProto2Value := "map[int64]*both.NinOptEnum{"
	for _, k := range keysForProto2Value {
		mapStringForProto2Value += fmt.Sprintf("%#v: %#v,", k, this.Proto2Value[k])
	}
	mapStringForProto2Value += "}"
	if this.Proto2Value != nil {
		s = append(s, "Proto2Value: "+mapStringForProto2Value+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Nested) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&theproto3.Nested{")
	s = append(s, "Bunny: "+fmt.Sprintf("%#v", this.Bunny)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AllMaps) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 21)
	s = append(s, "&theproto3.AllMaps{")
	keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
	for k := range this.StringToDoubleMap {
		keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
	mapStringForStringToDoubleMap := "map[string]float64{"
	for _, k := range keysForStringToDoubleMap {
		mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
	}
	mapStringForStringToDoubleMap += "}"
	if this.StringToDoubleMap != nil {
		s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
	}
	keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
	for k := range this.StringToFloatMap {
		keysForStringToFloatMap = append(keysForStringToFloatMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
	mapStringForStringToFloatMap := "map[string]float32{"
	for _, k := range keysForStringToFloatMap {
		mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
	}
	mapStringForStringToFloatMap += "}"
	if this.StringToFloatMap != nil {
		s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
	}
	keysForInt32Map := make([]int32, 0, len(this.Int32Map))
	for k := range this.Int32Map {
		keysForInt32Map = append(keysForInt32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
	mapStringForInt32Map := "map[int32]int32{"
	for _, k := range keysForInt32Map {
		mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
	}
	mapStringForInt32Map += "}"
	if this.Int32Map != nil {
		s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
	}
	keysForInt64Map := make([]int64, 0, len(this.Int64Map))
	for k := range this.Int64Map {
		keysForInt64Map = append(keysForInt64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
	mapStringForInt64Map := "map[int64]int64{"
	for _, k := range keysForInt64Map {
		mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
	}
	mapStringForInt64Map += "}"
	if this.Int64Map != nil {
		s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
	}
	keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
	for k := range this.Uint32Map {
		keysForUint32Map = append(keysForUint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
	mapStringForUint32Map := "map[uint32]uint32{"
	for _, k := range keysForUint32Map {
		mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
	}
	mapStringForUint32Map += "}"
	if this.Uint32Map != nil {
		s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
	}
	keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
	for k := range this.Uint64Map {
		keysForUint64Map = append(keysForUint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
	mapStringForUint64Map := "map[uint64]uint64{"
	for _, k := range keysForUint64Map {
		mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
	}
	mapStringForUint64Map += "}"
	if this.Uint64Map != nil {
		s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
	}
	keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
	for k := range this.Sint32Map {
		keysForSint32Map = append(keysForSint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
	mapStringForSint32Map := "map[int32]int32{"
	for _, k := range keysForSint32Map {
		mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
	}
	mapStringForSint32Map += "}"
	if this.Sint32Map != nil {
		s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
	}
	keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
	for k := range this.Sint64Map {
		keysForSint64Map = append(keysForSint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
	mapStringForSint64Map := "map[int64]int64{"
	for _, k := range keysForSint64Map {
		mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
	}
	mapStringForSint64Map += "}"
	if this.Sint64Map != nil {
		s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
	}
	keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
	for k := range this.Fixed32Map {
		keysForFixed32Map = append(keysForFixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
	mapStringForFixed32Map := "map[uint32]uint32{"
	for _, k := range keysForFixed32Map {
		mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
	}
	mapStringForFixed32Map += "}"
	if this.Fixed32Map != nil {
		s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
	}
	keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
	for k := range this.Sfixed32Map {
		keysForSfixed32Map = append(keysForSfixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
	mapStringForSfixed32Map := "map[int32]int32{"
	for _, k := range keysForSfixed32Map {
		mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
	}
	mapStringForSfixed32Map += "}"
	if this.Sfixed32Map != nil {
		s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
	}
	keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
	for k := range this.Fixed64Map {
		keysForFixed64Map = append(keysForFixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
	mapStringForFixed64Map := "map[uint64]uint64{"
	for _, k := range keysForFixed64Map {
		mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
	}
	mapStringForFixed64Map += "}"
	if this.Fixed64Map != nil {
		s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
	}
	keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
	for k := range this.Sfixed64Map {
		keysForSfixed64Map = append(keysForSfixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
	mapStringForSfixed64Map := "map[int64]int64{"
	for _, k := range keysForSfixed64Map {
		mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
	}
	mapStringForSfixed64Map += "}"
	if this.Sfixed64Map != nil {
		s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
	}
	keysForBoolMap := make([]bool, 0, len(this.BoolMap))
	for k := range this.BoolMap {
		keysForBoolMap = append(keysForBoolMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
	mapStringForBoolMap := "map[bool]bool{"
	for _, k := range keysForBoolMap {
		mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
	}
	mapStringForBoolMap += "}"
	if this.BoolMap != nil {
		s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
	}
	keysForStringMap := make([]string, 0, len(this.StringMap))
	for k := range this.StringMap {
		keysForStringMap = append(keysForStringMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
	mapStringForStringMap := "map[string]string{"
	for _, k := range keysForStringMap {
		mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
	}
	mapStringForStringMap += "}"
	if this.StringMap != nil {
		s = append(s, "StringMap: "+mapStringForStringMap+",\n")
	}
	keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
	for k := range this.StringToBytesMap {
		keysForStringToBytesMap = append(keysForStringToBytesMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
	mapStringForStringToBytesMap := "map[string][]byte{"
	for _, k := range keysForStringToBytesMap {
		mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
	}
	mapStringForStringToBytesMap += "}"
	if this.StringToBytesMap != nil {
		s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
	}
	keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
	for k := range this.StringToEnumMap {
		keysForStringToEnumMap = append(keysForStringToEnumMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
	mapStringForStringToEnumMap := "map[string]MapEnum{"
	for _, k := range keysForStringToEnumMap {
		mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
	}
	mapStringForStringToEnumMap += "}"
	if this.StringToEnumMap != nil {
		s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
	}
	keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
	for k := range this.StringToMsgMap {
		keysForStringToMsgMap = append(keysForStringToMsgMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
	mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
	for _, k := range keysForStringToMsgMap {
		mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
	}
	mapStringForStringToMsgMap += "}"
	if this.StringToMsgMap != nil {
		s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *AllMapsOrdered) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 21)
	s = append(s, "&theproto3.AllMapsOrdered{")
	keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
	for k := range this.StringToDoubleMap {
		keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
	mapStringForStringToDoubleMap := "map[string]float64{"
	for _, k := range keysForStringToDoubleMap {
		mapStringForStringToDoubleMap += fmt.Sprintf("%#v: %#v,", k, this.StringToDoubleMap[k])
	}
	mapStringForStringToDoubleMap += "}"
	if this.StringToDoubleMap != nil {
		s = append(s, "StringToDoubleMap: "+mapStringForStringToDoubleMap+",\n")
	}
	keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
	for k := range this.StringToFloatMap {
		keysForStringToFloatMap = append(keysForStringToFloatMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
	mapStringForStringToFloatMap := "map[string]float32{"
	for _, k := range keysForStringToFloatMap {
		mapStringForStringToFloatMap += fmt.Sprintf("%#v: %#v,", k, this.StringToFloatMap[k])
	}
	mapStringForStringToFloatMap += "}"
	if this.StringToFloatMap != nil {
		s = append(s, "StringToFloatMap: "+mapStringForStringToFloatMap+",\n")
	}
	keysForInt32Map := make([]int32, 0, len(this.Int32Map))
	for k := range this.Int32Map {
		keysForInt32Map = append(keysForInt32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
	mapStringForInt32Map := "map[int32]int32{"
	for _, k := range keysForInt32Map {
		mapStringForInt32Map += fmt.Sprintf("%#v: %#v,", k, this.Int32Map[k])
	}
	mapStringForInt32Map += "}"
	if this.Int32Map != nil {
		s = append(s, "Int32Map: "+mapStringForInt32Map+",\n")
	}
	keysForInt64Map := make([]int64, 0, len(this.Int64Map))
	for k := range this.Int64Map {
		keysForInt64Map = append(keysForInt64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
	mapStringForInt64Map := "map[int64]int64{"
	for _, k := range keysForInt64Map {
		mapStringForInt64Map += fmt.Sprintf("%#v: %#v,", k, this.Int64Map[k])
	}
	mapStringForInt64Map += "}"
	if this.Int64Map != nil {
		s = append(s, "Int64Map: "+mapStringForInt64Map+",\n")
	}
	keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
	for k := range this.Uint32Map {
		keysForUint32Map = append(keysForUint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
	mapStringForUint32Map := "map[uint32]uint32{"
	for _, k := range keysForUint32Map {
		mapStringForUint32Map += fmt.Sprintf("%#v: %#v,", k, this.Uint32Map[k])
	}
	mapStringForUint32Map += "}"
	if this.Uint32Map != nil {
		s = append(s, "Uint32Map: "+mapStringForUint32Map+",\n")
	}
	keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
	for k := range this.Uint64Map {
		keysForUint64Map = append(keysForUint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
	mapStringForUint64Map := "map[uint64]uint64{"
	for _, k := range keysForUint64Map {
		mapStringForUint64Map += fmt.Sprintf("%#v: %#v,", k, this.Uint64Map[k])
	}
	mapStringForUint64Map += "}"
	if this.Uint64Map != nil {
		s = append(s, "Uint64Map: "+mapStringForUint64Map+",\n")
	}
	keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
	for k := range this.Sint32Map {
		keysForSint32Map = append(keysForSint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
	mapStringForSint32Map := "map[int32]int32{"
	for _, k := range keysForSint32Map {
		mapStringForSint32Map += fmt.Sprintf("%#v: %#v,", k, this.Sint32Map[k])
	}
	mapStringForSint32Map += "}"
	if this.Sint32Map != nil {
		s = append(s, "Sint32Map: "+mapStringForSint32Map+",\n")
	}
	keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
	for k := range this.Sint64Map {
		keysForSint64Map = append(keysForSint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
	mapStringForSint64Map := "map[int64]int64{"
	for _, k := range keysForSint64Map {
		mapStringForSint64Map += fmt.Sprintf("%#v: %#v,", k, this.Sint64Map[k])
	}
	mapStringForSint64Map += "}"
	if this.Sint64Map != nil {
		s = append(s, "Sint64Map: "+mapStringForSint64Map+",\n")
	}
	keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
	for k := range this.Fixed32Map {
		keysForFixed32Map = append(keysForFixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
	mapStringForFixed32Map := "map[uint32]uint32{"
	for _, k := range keysForFixed32Map {
		mapStringForFixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed32Map[k])
	}
	mapStringForFixed32Map += "}"
	if this.Fixed32Map != nil {
		s = append(s, "Fixed32Map: "+mapStringForFixed32Map+",\n")
	}
	keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
	for k := range this.Sfixed32Map {
		keysForSfixed32Map = append(keysForSfixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
	mapStringForSfixed32Map := "map[int32]int32{"
	for _, k := range keysForSfixed32Map {
		mapStringForSfixed32Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed32Map[k])
	}
	mapStringForSfixed32Map += "}"
	if this.Sfixed32Map != nil {
		s = append(s, "Sfixed32Map: "+mapStringForSfixed32Map+",\n")
	}
	keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
	for k := range this.Fixed64Map {
		keysForFixed64Map = append(keysForFixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
	mapStringForFixed64Map := "map[uint64]uint64{"
	for _, k := range keysForFixed64Map {
		mapStringForFixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Fixed64Map[k])
	}
	mapStringForFixed64Map += "}"
	if this.Fixed64Map != nil {
		s = append(s, "Fixed64Map: "+mapStringForFixed64Map+",\n")
	}
	keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
	for k := range this.Sfixed64Map {
		keysForSfixed64Map = append(keysForSfixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
	mapStringForSfixed64Map := "map[int64]int64{"
	for _, k := range keysForSfixed64Map {
		mapStringForSfixed64Map += fmt.Sprintf("%#v: %#v,", k, this.Sfixed64Map[k])
	}
	mapStringForSfixed64Map += "}"
	if this.Sfixed64Map != nil {
		s = append(s, "Sfixed64Map: "+mapStringForSfixed64Map+",\n")
	}
	keysForBoolMap := make([]bool, 0, len(this.BoolMap))
	for k := range this.BoolMap {
		keysForBoolMap = append(keysForBoolMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
	mapStringForBoolMap := "map[bool]bool{"
	for _, k := range keysForBoolMap {
		mapStringForBoolMap += fmt.Sprintf("%#v: %#v,", k, this.BoolMap[k])
	}
	mapStringForBoolMap += "}"
	if this.BoolMap != nil {
		s = append(s, "BoolMap: "+mapStringForBoolMap+",\n")
	}
	keysForStringMap := make([]string, 0, len(this.StringMap))
	for k := range this.StringMap {
		keysForStringMap = append(keysForStringMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
	mapStringForStringMap := "map[string]string{"
	for _, k := range keysForStringMap {
		mapStringForStringMap += fmt.Sprintf("%#v: %#v,", k, this.StringMap[k])
	}
	mapStringForStringMap += "}"
	if this.StringMap != nil {
		s = append(s, "StringMap: "+mapStringForStringMap+",\n")
	}
	keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
	for k := range this.StringToBytesMap {
		keysForStringToBytesMap = append(keysForStringToBytesMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
	mapStringForStringToBytesMap := "map[string][]byte{"
	for _, k := range keysForStringToBytesMap {
		mapStringForStringToBytesMap += fmt.Sprintf("%#v: %#v,", k, this.StringToBytesMap[k])
	}
	mapStringForStringToBytesMap += "}"
	if this.StringToBytesMap != nil {
		s = append(s, "StringToBytesMap: "+mapStringForStringToBytesMap+",\n")
	}
	keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
	for k := range this.StringToEnumMap {
		keysForStringToEnumMap = append(keysForStringToEnumMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
	mapStringForStringToEnumMap := "map[string]MapEnum{"
	for _, k := range keysForStringToEnumMap {
		mapStringForStringToEnumMap += fmt.Sprintf("%#v: %#v,", k, this.StringToEnumMap[k])
	}
	mapStringForStringToEnumMap += "}"
	if this.StringToEnumMap != nil {
		s = append(s, "StringToEnumMap: "+mapStringForStringToEnumMap+",\n")
	}
	keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
	for k := range this.StringToMsgMap {
		keysForStringToMsgMap = append(keysForStringToMsgMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
	mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
	for _, k := range keysForStringToMsgMap {
		mapStringForStringToMsgMap += fmt.Sprintf("%#v: %#v,", k, this.StringToMsgMap[k])
	}
	mapStringForStringToMsgMap += "}"
	if this.StringToMsgMap != nil {
		s = append(s, "StringToMsgMap: "+mapStringForStringToMsgMap+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MessageWithMap) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&theproto3.MessageWithMap{")
	keysForNameMapping := make([]int32, 0, len(this.NameMapping))
	for k := range this.NameMapping {
		keysForNameMapping = append(keysForNameMapping, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping)
	mapStringForNameMapping := "map[int32]string{"
	for _, k := range keysForNameMapping {
		mapStringForNameMapping += fmt.Sprintf("%#v: %#v,", k, this.NameMapping[k])
	}
	mapStringForNameMapping += "}"
	if this.NameMapping != nil {
		s = append(s, "NameMapping: "+mapStringForNameMapping+",\n")
	}
	keysForMsgMapping := make([]int64, 0, len(this.MsgMapping))
	for k := range this.MsgMapping {
		keysForMsgMapping = append(keysForMsgMapping, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping)
	mapStringForMsgMapping := "map[int64]*FloatingPoint{"
	for _, k := range keysForMsgMapping {
		mapStringForMsgMapping += fmt.Sprintf("%#v: %#v,", k, this.MsgMapping[k])
	}
	mapStringForMsgMapping += "}"
	if this.MsgMapping != nil {
		s = append(s, "MsgMapping: "+mapStringForMsgMapping+",\n")
	}
	keysForByteMapping := make([]bool, 0, len(this.ByteMapping))
	for k := range this.ByteMapping {
		keysForByteMapping = append(keysForByteMapping, k)
	}
	github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping)
	mapStringForByteMapping := "map[bool][]byte{"
	for _, k := range keysForByteMapping {
		mapStringForByteMapping += fmt.Sprintf("%#v: %#v,", k, this.ByteMapping[k])
	}
	mapStringForByteMapping += "}"
	if this.ByteMapping != nil {
		s = append(s, "ByteMapping: "+mapStringForByteMapping+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *FloatingPoint) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&theproto3.FloatingPoint{")
	s = append(s, "F: "+fmt.Sprintf("%#v", this.F)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Uint128Pair) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&theproto3.Uint128Pair{")
	s = append(s, "Left: "+fmt.Sprintf("%#v", this.Left)+",\n")
	s = append(s, "Right: "+fmt.Sprintf("%#v", this.Right)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ContainsNestedMap) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&theproto3.ContainsNestedMap{")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ContainsNestedMap_NestedMap) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&theproto3.ContainsNestedMap_NestedMap{")
	keysForNestedMapField := make([]string, 0, len(this.NestedMapField))
	for k := range this.NestedMapField {
		keysForNestedMapField = append(keysForNestedMapField, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNestedMapField)
	mapStringForNestedMapField := "map[string]float64{"
	for _, k := range keysForNestedMapField {
		mapStringForNestedMapField += fmt.Sprintf("%#v: %#v,", k, this.NestedMapField[k])
	}
	mapStringForNestedMapField += "}"
	if this.NestedMapField != nil {
		s = append(s, "NestedMapField: "+mapStringForNestedMapField+",\n")
	}
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *NotPacked) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&theproto3.NotPacked{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	if this.XXX_unrecognized != nil {
		s = append(s, "XXX_unrecognized:"+fmt.Sprintf("%#v", this.XXX_unrecognized)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringTheproto3(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *Message) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Message) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Proto2Value) > 0 {
		for k := range m.Proto2Value {
			v := m.Proto2Value[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTheproto3(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if m.Proto2Field != nil {
		{
			size, err := m.Proto2Field.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTheproto3(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if len(m.Terrain) > 0 {
		for k := range m.Terrain {
			v := m.Terrain[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTheproto3(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if m.Score != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Score))))
		i--
		dAtA[i] = 0x4d
	}
	if m.TrueScotsman {
		i--
		if m.TrueScotsman {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.ResultCount != 0 {
		i = encodeVarintTheproto3(dAtA, i, uint64(m.ResultCount))
		i--
		dAtA[i] = 0x38
	}
	if m.Nested != nil {
		{
			size, err := m.Nested.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTheproto3(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.Key) > 0 {
		dAtA6 := make([]byte, len(m.Key)*10)
		var j5 int
		for _, num := range m.Key {
			for num >= 1<<7 {
				dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j5++
			}
			dAtA6[j5] = uint8(num)
			j5++
		}
		i -= j5
		copy(dAtA[i:], dAtA6[:j5])
		i = encodeVarintTheproto3(dAtA, i, uint64(j5))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x22
	}
	if m.HeightInCm != 0 {
		i = encodeVarintTheproto3(dAtA, i, uint64(m.HeightInCm))
		i--
		dAtA[i] = 0x18
	}
	if m.Hilarity != 0 {
		i = encodeVarintTheproto3(dAtA, i, uint64(m.Hilarity))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Nested) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Nested) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Nested) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Bunny) > 0 {
		i -= len(m.Bunny)
		copy(dAtA[i:], m.Bunny)
		i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Bunny)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *AllMaps) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AllMaps) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AllMaps) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.StringToMsgMap) > 0 {
		for k := range m.StringToMsgMap {
			v := m.StringToMsgMap[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTheproto3(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.StringToEnumMap) > 0 {
		for k := range m.StringToEnumMap {
			v := m.StringToEnumMap[k]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.StringToBytesMap) > 0 {
		for k := range m.StringToBytesMap {
			v := m.StringToBytesMap[k]
			baseI := i
			if len(v) > 0 {
				i -= len(v)
				copy(dAtA[i:], v)
				i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.StringMap) > 0 {
		for k := range m.StringMap {
			v := m.StringMap[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.BoolMap) > 0 {
		for k := range m.BoolMap {
			v := m.BoolMap[k]
			baseI := i
			i--
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x10
			i--
			if k {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.Sfixed64Map) > 0 {
		for k := range m.Sfixed64Map {
			v := m.Sfixed64Map[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(k))
			i--
			dAtA[i] = 0x9
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.Fixed64Map) > 0 {
		for k := range m.Fixed64Map {
			v := m.Fixed64Map[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(k))
			i--
			dAtA[i] = 0x9
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.Sfixed32Map) > 0 {
		for k := range m.Sfixed32Map {
			v := m.Sfixed32Map[k]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
			i--
			dAtA[i] = 0x15
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
			i--
			dAtA[i] = 0xd
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.Fixed32Map) > 0 {
		for k := range m.Fixed32Map {
			v := m.Fixed32Map[k]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
			i--
			dAtA[i] = 0x15
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(k))
			i--
			dAtA[i] = 0xd
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.Sint64Map) > 0 {
		for k := range m.Sint64Map {
			v := m.Sint64Map[k]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(k)<<1)^uint64((k>>63))))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Sint32Map) > 0 {
		for k := range m.Sint32Map {
			v := m.Sint32Map[k]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64((uint32(k)<<1)^uint32((k>>31))))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Uint64Map) > 0 {
		for k := range m.Uint64Map {
			v := m.Uint64Map[k]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Uint32Map) > 0 {
		for k := range m.Uint32Map {
			v := m.Uint32Map[k]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Int64Map) > 0 {
		for k := range m.Int64Map {
			v := m.Int64Map[k]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Int32Map) > 0 {
		for k := range m.Int32Map {
			v := m.Int32Map[k]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.StringToFloatMap) > 0 {
		for k := range m.StringToFloatMap {
			v := m.StringToFloatMap[k]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
			i--
			dAtA[i] = 0x15
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.StringToDoubleMap) > 0 {
		for k := range m.StringToDoubleMap {
			v := m.StringToDoubleMap[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
			i--
			dAtA[i] = 0x11
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *AllMapsOrdered) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *AllMapsOrdered) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AllMapsOrdered) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.StringToMsgMap) > 0 {
		keysForStringToMsgMap := make([]string, 0, len(m.StringToMsgMap))
		for k := range m.StringToMsgMap {
			keysForStringToMsgMap = append(keysForStringToMsgMap, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
		for iNdEx := len(keysForStringToMsgMap) - 1; iNdEx >= 0; iNdEx-- {
			v := m.StringToMsgMap[string(keysForStringToMsgMap[iNdEx])]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTheproto3(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(keysForStringToMsgMap[iNdEx])
			copy(dAtA[i:], keysForStringToMsgMap[iNdEx])
			i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToMsgMap[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.StringToEnumMap) > 0 {
		keysForStringToEnumMap := make([]string, 0, len(m.StringToEnumMap))
		for k := range m.StringToEnumMap {
			keysForStringToEnumMap = append(keysForStringToEnumMap, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
		for iNdEx := len(keysForStringToEnumMap) - 1; iNdEx >= 0; iNdEx-- {
			v := m.StringToEnumMap[string(keysForStringToEnumMap[iNdEx])]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(keysForStringToEnumMap[iNdEx])
			copy(dAtA[i:], keysForStringToEnumMap[iNdEx])
			i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToEnumMap[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.StringToBytesMap) > 0 {
		keysForStringToBytesMap := make([]string, 0, len(m.StringToBytesMap))
		for k := range m.StringToBytesMap {
			keysForStringToBytesMap = append(keysForStringToBytesMap, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
		for iNdEx := len(keysForStringToBytesMap) - 1; iNdEx >= 0; iNdEx-- {
			v := m.StringToBytesMap[string(keysForStringToBytesMap[iNdEx])]
			baseI := i
			if len(v) > 0 {
				i -= len(v)
				copy(dAtA[i:], v)
				i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
				i--
				dAtA[i] = 0x12
			}
			i -= len(keysForStringToBytesMap[iNdEx])
			copy(dAtA[i:], keysForStringToBytesMap[iNdEx])
			i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToBytesMap[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.StringMap) > 0 {
		keysForStringMap := make([]string, 0, len(m.StringMap))
		for k := range m.StringMap {
			keysForStringMap = append(keysForStringMap, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
		for iNdEx := len(keysForStringMap) - 1; iNdEx >= 0; iNdEx-- {
			v := m.StringMap[string(keysForStringMap[iNdEx])]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(keysForStringMap[iNdEx])
			copy(dAtA[i:], keysForStringMap[iNdEx])
			i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringMap[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.BoolMap) > 0 {
		keysForBoolMap := make([]bool, 0, len(m.BoolMap))
		for k := range m.BoolMap {
			keysForBoolMap = append(keysForBoolMap, bool(k))
		}
		github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
		for iNdEx := len(keysForBoolMap) - 1; iNdEx >= 0; iNdEx-- {
			v := m.BoolMap[bool(keysForBoolMap[iNdEx])]
			baseI := i
			i--
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x10
			i--
			if keysForBoolMap[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if len(m.Sfixed64Map) > 0 {
		keysForSfixed64Map := make([]int64, 0, len(m.Sfixed64Map))
		for k := range m.Sfixed64Map {
			keysForSfixed64Map = append(keysForSfixed64Map, int64(k))
		}
		github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
		for iNdEx := len(keysForSfixed64Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Sfixed64Map[int64(keysForSfixed64Map[iNdEx])]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(keysForSfixed64Map[iNdEx]))
			i--
			dAtA[i] = 0x9
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.Fixed64Map) > 0 {
		keysForFixed64Map := make([]uint64, 0, len(m.Fixed64Map))
		for k := range m.Fixed64Map {
			keysForFixed64Map = append(keysForFixed64Map, uint64(k))
		}
		github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
		for iNdEx := len(keysForFixed64Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Fixed64Map[uint64(keysForFixed64Map[iNdEx])]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(v))
			i--
			dAtA[i] = 0x11
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(keysForFixed64Map[iNdEx]))
			i--
			dAtA[i] = 0x9
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.Sfixed32Map) > 0 {
		keysForSfixed32Map := make([]int32, 0, len(m.Sfixed32Map))
		for k := range m.Sfixed32Map {
			keysForSfixed32Map = append(keysForSfixed32Map, int32(k))
		}
		github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
		for iNdEx := len(keysForSfixed32Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Sfixed32Map[int32(keysForSfixed32Map[iNdEx])]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
			i--
			dAtA[i] = 0x15
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(keysForSfixed32Map[iNdEx]))
			i--
			dAtA[i] = 0xd
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.Fixed32Map) > 0 {
		keysForFixed32Map := make([]uint32, 0, len(m.Fixed32Map))
		for k := range m.Fixed32Map {
			keysForFixed32Map = append(keysForFixed32Map, uint32(k))
		}
		github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
		for iNdEx := len(keysForFixed32Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Fixed32Map[uint32(keysForFixed32Map[iNdEx])]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(v))
			i--
			dAtA[i] = 0x15
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(keysForFixed32Map[iNdEx]))
			i--
			dAtA[i] = 0xd
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.Sint64Map) > 0 {
		keysForSint64Map := make([]int64, 0, len(m.Sint64Map))
		for k := range m.Sint64Map {
			keysForSint64Map = append(keysForSint64Map, int64(k))
		}
		github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
		for iNdEx := len(keysForSint64Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Sint64Map[int64(keysForSint64Map[iNdEx])]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(keysForSint64Map[iNdEx])<<1)^uint64((keysForSint64Map[iNdEx]>>63))))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.Sint32Map) > 0 {
		keysForSint32Map := make([]int32, 0, len(m.Sint32Map))
		for k := range m.Sint32Map {
			keysForSint32Map = append(keysForSint32Map, int32(k))
		}
		github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
		for iNdEx := len(keysForSint32Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Sint32Map[int32(keysForSint32Map[iNdEx])]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64((uint32(keysForSint32Map[iNdEx])<<1)^uint32((keysForSint32Map[iNdEx]>>31))))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Uint64Map) > 0 {
		keysForUint64Map := make([]uint64, 0, len(m.Uint64Map))
		for k := range m.Uint64Map {
			keysForUint64Map = append(keysForUint64Map, uint64(k))
		}
		github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
		for iNdEx := len(keysForUint64Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Uint64Map[uint64(keysForUint64Map[iNdEx])]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(keysForUint64Map[iNdEx]))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Uint32Map) > 0 {
		keysForUint32Map := make([]uint32, 0, len(m.Uint32Map))
		for k := range m.Uint32Map {
			keysForUint32Map = append(keysForUint32Map, uint32(k))
		}
		github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
		for iNdEx := len(keysForUint32Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Uint32Map[uint32(keysForUint32Map[iNdEx])]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(keysForUint32Map[iNdEx]))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Int64Map) > 0 {
		keysForInt64Map := make([]int64, 0, len(m.Int64Map))
		for k := range m.Int64Map {
			keysForInt64Map = append(keysForInt64Map, int64(k))
		}
		github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
		for iNdEx := len(keysForInt64Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Int64Map[int64(keysForInt64Map[iNdEx])]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(keysForInt64Map[iNdEx]))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Int32Map) > 0 {
		keysForInt32Map := make([]int32, 0, len(m.Int32Map))
		for k := range m.Int32Map {
			keysForInt32Map = append(keysForInt32Map, int32(k))
		}
		github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
		for iNdEx := len(keysForInt32Map) - 1; iNdEx >= 0; iNdEx-- {
			v := m.Int32Map[int32(keysForInt32Map[iNdEx])]
			baseI := i
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintTheproto3(dAtA, i, uint64(keysForInt32Map[iNdEx]))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.StringToFloatMap) > 0 {
		keysForStringToFloatMap := make([]string, 0, len(m.StringToFloatMap))
		for k := range m.StringToFloatMap {
			keysForStringToFloatMap = append(keysForStringToFloatMap, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
		for iNdEx := len(keysForStringToFloatMap) - 1; iNdEx >= 0; iNdEx-- {
			v := m.StringToFloatMap[string(keysForStringToFloatMap[iNdEx])]
			baseI := i
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(v))))
			i--
			dAtA[i] = 0x15
			i -= len(keysForStringToFloatMap[iNdEx])
			copy(dAtA[i:], keysForStringToFloatMap[iNdEx])
			i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToFloatMap[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.StringToDoubleMap) > 0 {
		keysForStringToDoubleMap := make([]string, 0, len(m.StringToDoubleMap))
		for k := range m.StringToDoubleMap {
			keysForStringToDoubleMap = append(keysForStringToDoubleMap, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
		for iNdEx := len(keysForStringToDoubleMap) - 1; iNdEx >= 0; iNdEx-- {
			v := m.StringToDoubleMap[string(keysForStringToDoubleMap[iNdEx])]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
			i--
			dAtA[i] = 0x11
			i -= len(keysForStringToDoubleMap[iNdEx])
			copy(dAtA[i:], keysForStringToDoubleMap[iNdEx])
			i = encodeVarintTheproto3(dAtA, i, uint64(len(keysForStringToDoubleMap[iNdEx])))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *MessageWithMap) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MessageWithMap) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageWithMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ByteMapping) > 0 {
		for k := range m.ByteMapping {
			v := m.ByteMapping[k]
			baseI := i
			if len(v) > 0 {
				i -= len(v)
				copy(dAtA[i:], v)
				i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
				i--
				dAtA[i] = 0x12
			}
			i--
			if k {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.MsgMapping) > 0 {
		for k := range m.MsgMapping {
			v := m.MsgMapping[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTheproto3(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(k)<<1)^uint64((k>>63))))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.NameMapping) > 0 {
		for k := range m.NameMapping {
			v := m.NameMapping[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *FloatingPoint) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FloatingPoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FloatingPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.F != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.F))))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *Uint128Pair) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Uint128Pair) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Uint128Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Right != nil {
		{
			size := m.Right.Size()
			i -= size
			if _, err := m.Right.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintTheproto3(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Left.Size()
		i -= size
		if _, err := m.Left.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTheproto3(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ContainsNestedMap) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ContainsNestedMap) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ContainsNestedMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *ContainsNestedMap_NestedMap) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ContainsNestedMap_NestedMap) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ContainsNestedMap_NestedMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NestedMapField) > 0 {
		for k := range m.NestedMapField {
			v := m.NestedMapField[k]
			baseI := i
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(v))))
			i--
			dAtA[i] = 0x11
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTheproto3(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *NotPacked) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *NotPacked) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NotPacked) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Key) > 0 {
		for iNdEx := len(m.Key) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintTheproto3(dAtA, i, uint64(m.Key[iNdEx]))
			i--
			dAtA[i] = 0x28
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintTheproto3(dAtA []byte, offset int, v uint64) int {
	offset -= sovTheproto3(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedMessage(r randyTheproto3, easy bool) *Message {
	this := &Message{}
	this.Name = string(randStringTheproto3(r))
	this.Hilarity = Message_Humour([]int32{0, 1, 2, 3}[r.Intn(4)])
	this.HeightInCm = uint32(r.Uint32())
	v1 := r.Intn(100)
	this.Data = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	v2 := r.Intn(10)
	this.Key = make([]uint64, v2)
	for i := 0; i < v2; i++ {
		this.Key[i] = uint64(uint64(r.Uint32()))
	}
	if r.Intn(5) != 0 {
		this.Nested = NewPopulatedNested(r, easy)
	}
	this.ResultCount = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.ResultCount *= -1
	}
	this.TrueScotsman = bool(bool(r.Intn(2) == 0))
	this.Score = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Score *= -1
	}
	if r.Intn(5) != 0 {
		v3 := r.Intn(10)
		this.Terrain = make(map[int64]*Nested)
		for i := 0; i < v3; i++ {
			this.Terrain[int64(r.Int63())] = NewPopulatedNested(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		this.Proto2Field = both.NewPopulatedNinOptNative(r, easy)
	}
	if r.Intn(5) != 0 {
		v4 := r.Intn(10)
		this.Proto2Value = make(map[int64]*both.NinOptEnum)
		for i := 0; i < v4; i++ {
			this.Proto2Value[int64(r.Int63())] = both.NewPopulatedNinOptEnum(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 14)
	}
	return this
}

func NewPopulatedNested(r randyTheproto3, easy bool) *Nested {
	this := &Nested{}
	this.Bunny = string(randStringTheproto3(r))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
	}
	return this
}

func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps {
	this := &AllMaps{}
	if r.Intn(5) != 0 {
		v5 := r.Intn(10)
		this.StringToDoubleMap = make(map[string]float64)
		for i := 0; i < v5; i++ {
			v6 := randStringTheproto3(r)
			this.StringToDoubleMap[v6] = float64(r.Float64())
			if r.Intn(2) == 0 {
				this.StringToDoubleMap[v6] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v7 := r.Intn(10)
		this.StringToFloatMap = make(map[string]float32)
		for i := 0; i < v7; i++ {
			v8 := randStringTheproto3(r)
			this.StringToFloatMap[v8] = float32(r.Float32())
			if r.Intn(2) == 0 {
				this.StringToFloatMap[v8] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v9 := r.Intn(10)
		this.Int32Map = make(map[int32]int32)
		for i := 0; i < v9; i++ {
			v10 := int32(r.Int31())
			this.Int32Map[v10] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.Int32Map[v10] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v11 := r.Intn(10)
		this.Int64Map = make(map[int64]int64)
		for i := 0; i < v11; i++ {
			v12 := int64(r.Int63())
			this.Int64Map[v12] = int64(r.Int63())
			if r.Intn(2) == 0 {
				this.Int64Map[v12] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v13 := r.Intn(10)
		this.Uint32Map = make(map[uint32]uint32)
		for i := 0; i < v13; i++ {
			v14 := uint32(r.Uint32())
			this.Uint32Map[v14] = uint32(r.Uint32())
		}
	}
	if r.Intn(5) != 0 {
		v15 := r.Intn(10)
		this.Uint64Map = make(map[uint64]uint64)
		for i := 0; i < v15; i++ {
			v16 := uint64(uint64(r.Uint32()))
			this.Uint64Map[v16] = uint64(uint64(r.Uint32()))
		}
	}
	if r.Intn(5) != 0 {
		v17 := r.Intn(10)
		this.Sint32Map = make(map[int32]int32)
		for i := 0; i < v17; i++ {
			v18 := int32(r.Int31())
			this.Sint32Map[v18] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.Sint32Map[v18] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v19 := r.Intn(10)
		this.Sint64Map = make(map[int64]int64)
		for i := 0; i < v19; i++ {
			v20 := int64(r.Int63())
			this.Sint64Map[v20] = int64(r.Int63())
			if r.Intn(2) == 0 {
				this.Sint64Map[v20] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v21 := r.Intn(10)
		this.Fixed32Map = make(map[uint32]uint32)
		for i := 0; i < v21; i++ {
			v22 := uint32(r.Uint32())
			this.Fixed32Map[v22] = uint32(r.Uint32())
		}
	}
	if r.Intn(5) != 0 {
		v23 := r.Intn(10)
		this.Sfixed32Map = make(map[int32]int32)
		for i := 0; i < v23; i++ {
			v24 := int32(r.Int31())
			this.Sfixed32Map[v24] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.Sfixed32Map[v24] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v25 := r.Intn(10)
		this.Fixed64Map = make(map[uint64]uint64)
		for i := 0; i < v25; i++ {
			v26 := uint64(uint64(r.Uint32()))
			this.Fixed64Map[v26] = uint64(uint64(r.Uint32()))
		}
	}
	if r.Intn(5) != 0 {
		v27 := r.Intn(10)
		this.Sfixed64Map = make(map[int64]int64)
		for i := 0; i < v27; i++ {
			v28 := int64(r.Int63())
			this.Sfixed64Map[v28] = int64(r.Int63())
			if r.Intn(2) == 0 {
				this.Sfixed64Map[v28] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v29 := r.Intn(10)
		this.BoolMap = make(map[bool]bool)
		for i := 0; i < v29; i++ {
			v30 := bool(bool(r.Intn(2) == 0))
			this.BoolMap[v30] = bool(bool(r.Intn(2) == 0))
		}
	}
	if r.Intn(5) != 0 {
		v31 := r.Intn(10)
		this.StringMap = make(map[string]string)
		for i := 0; i < v31; i++ {
			this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r)
		}
	}
	if r.Intn(5) != 0 {
		v32 := r.Intn(10)
		this.StringToBytesMap = make(map[string][]byte)
		for i := 0; i < v32; i++ {
			v33 := r.Intn(100)
			v34 := randStringTheproto3(r)
			this.StringToBytesMap[v34] = make([]byte, v33)
			for i := 0; i < v33; i++ {
				this.StringToBytesMap[v34][i] = byte(r.Intn(256))
			}
		}
	}
	if r.Intn(5) != 0 {
		v35 := r.Intn(10)
		this.StringToEnumMap = make(map[string]MapEnum)
		for i := 0; i < v35; i++ {
			this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
		}
	}
	if r.Intn(5) != 0 {
		v36 := r.Intn(10)
		this.StringToMsgMap = make(map[string]*FloatingPoint)
		for i := 0; i < v36; i++ {
			this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 18)
	}
	return this
}

func NewPopulatedAllMapsOrdered(r randyTheproto3, easy bool) *AllMapsOrdered {
	this := &AllMapsOrdered{}
	if r.Intn(5) != 0 {
		v37 := r.Intn(10)
		this.StringToDoubleMap = make(map[string]float64)
		for i := 0; i < v37; i++ {
			v38 := randStringTheproto3(r)
			this.StringToDoubleMap[v38] = float64(r.Float64())
			if r.Intn(2) == 0 {
				this.StringToDoubleMap[v38] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v39 := r.Intn(10)
		this.StringToFloatMap = make(map[string]float32)
		for i := 0; i < v39; i++ {
			v40 := randStringTheproto3(r)
			this.StringToFloatMap[v40] = float32(r.Float32())
			if r.Intn(2) == 0 {
				this.StringToFloatMap[v40] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v41 := r.Intn(10)
		this.Int32Map = make(map[int32]int32)
		for i := 0; i < v41; i++ {
			v42 := int32(r.Int31())
			this.Int32Map[v42] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.Int32Map[v42] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v43 := r.Intn(10)
		this.Int64Map = make(map[int64]int64)
		for i := 0; i < v43; i++ {
			v44 := int64(r.Int63())
			this.Int64Map[v44] = int64(r.Int63())
			if r.Intn(2) == 0 {
				this.Int64Map[v44] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v45 := r.Intn(10)
		this.Uint32Map = make(map[uint32]uint32)
		for i := 0; i < v45; i++ {
			v46 := uint32(r.Uint32())
			this.Uint32Map[v46] = uint32(r.Uint32())
		}
	}
	if r.Intn(5) != 0 {
		v47 := r.Intn(10)
		this.Uint64Map = make(map[uint64]uint64)
		for i := 0; i < v47; i++ {
			v48 := uint64(uint64(r.Uint32()))
			this.Uint64Map[v48] = uint64(uint64(r.Uint32()))
		}
	}
	if r.Intn(5) != 0 {
		v49 := r.Intn(10)
		this.Sint32Map = make(map[int32]int32)
		for i := 0; i < v49; i++ {
			v50 := int32(r.Int31())
			this.Sint32Map[v50] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.Sint32Map[v50] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v51 := r.Intn(10)
		this.Sint64Map = make(map[int64]int64)
		for i := 0; i < v51; i++ {
			v52 := int64(r.Int63())
			this.Sint64Map[v52] = int64(r.Int63())
			if r.Intn(2) == 0 {
				this.Sint64Map[v52] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v53 := r.Intn(10)
		this.Fixed32Map = make(map[uint32]uint32)
		for i := 0; i < v53; i++ {
			v54 := uint32(r.Uint32())
			this.Fixed32Map[v54] = uint32(r.Uint32())
		}
	}
	if r.Intn(5) != 0 {
		v55 := r.Intn(10)
		this.Sfixed32Map = make(map[int32]int32)
		for i := 0; i < v55; i++ {
			v56 := int32(r.Int31())
			this.Sfixed32Map[v56] = int32(r.Int31())
			if r.Intn(2) == 0 {
				this.Sfixed32Map[v56] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v57 := r.Intn(10)
		this.Fixed64Map = make(map[uint64]uint64)
		for i := 0; i < v57; i++ {
			v58 := uint64(uint64(r.Uint32()))
			this.Fixed64Map[v58] = uint64(uint64(r.Uint32()))
		}
	}
	if r.Intn(5) != 0 {
		v59 := r.Intn(10)
		this.Sfixed64Map = make(map[int64]int64)
		for i := 0; i < v59; i++ {
			v60 := int64(r.Int63())
			this.Sfixed64Map[v60] = int64(r.Int63())
			if r.Intn(2) == 0 {
				this.Sfixed64Map[v60] *= -1
			}
		}
	}
	if r.Intn(5) != 0 {
		v61 := r.Intn(10)
		this.BoolMap = make(map[bool]bool)
		for i := 0; i < v61; i++ {
			v62 := bool(bool(r.Intn(2) == 0))
			this.BoolMap[v62] = bool(bool(r.Intn(2) == 0))
		}
	}
	if r.Intn(5) != 0 {
		v63 := r.Intn(10)
		this.StringMap = make(map[string]string)
		for i := 0; i < v63; i++ {
			this.StringMap[randStringTheproto3(r)] = randStringTheproto3(r)
		}
	}
	if r.Intn(5) != 0 {
		v64 := r.Intn(10)
		this.StringToBytesMap = make(map[string][]byte)
		for i := 0; i < v64; i++ {
			v65 := r.Intn(100)
			v66 := randStringTheproto3(r)
			this.StringToBytesMap[v66] = make([]byte, v65)
			for i := 0; i < v65; i++ {
				this.StringToBytesMap[v66][i] = byte(r.Intn(256))
			}
		}
	}
	if r.Intn(5) != 0 {
		v67 := r.Intn(10)
		this.StringToEnumMap = make(map[string]MapEnum)
		for i := 0; i < v67; i++ {
			this.StringToEnumMap[randStringTheproto3(r)] = MapEnum([]int32{0, 1, 2}[r.Intn(3)])
		}
	}
	if r.Intn(5) != 0 {
		v68 := r.Intn(10)
		this.StringToMsgMap = make(map[string]*FloatingPoint)
		for i := 0; i < v68; i++ {
			this.StringToMsgMap[randStringTheproto3(r)] = NewPopulatedFloatingPoint(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 18)
	}
	return this
}

func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap {
	this := &MessageWithMap{}
	if r.Intn(5) != 0 {
		v69 := r.Intn(10)
		this.NameMapping = make(map[int32]string)
		for i := 0; i < v69; i++ {
			this.NameMapping[int32(r.Int31())] = randStringTheproto3(r)
		}
	}
	if r.Intn(5) != 0 {
		v70 := r.Intn(10)
		this.MsgMapping = make(map[int64]*FloatingPoint)
		for i := 0; i < v70; i++ {
			this.MsgMapping[int64(r.Int63())] = NewPopulatedFloatingPoint(r, easy)
		}
	}
	if r.Intn(5) != 0 {
		v71 := r.Intn(10)
		this.ByteMapping = make(map[bool][]byte)
		for i := 0; i < v71; i++ {
			v72 := r.Intn(100)
			v73 := bool(bool(r.Intn(2) == 0))
			this.ByteMapping[v73] = make([]byte, v72)
			for i := 0; i < v72; i++ {
				this.ByteMapping[v73][i] = byte(r.Intn(256))
			}
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 4)
	}
	return this
}

func NewPopulatedFloatingPoint(r randyTheproto3, easy bool) *FloatingPoint {
	this := &FloatingPoint{}
	this.F = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.F *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
	}
	return this
}

func NewPopulatedUint128Pair(r randyTheproto3, easy bool) *Uint128Pair {
	this := &Uint128Pair{}
	v74 := github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
	this.Left = *v74
	this.Right = github_com_gogo_protobuf_test_custom.NewPopulatedUint128(r)
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 3)
	}
	return this
}

func NewPopulatedContainsNestedMap(r randyTheproto3, easy bool) *ContainsNestedMap {
	this := &ContainsNestedMap{}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 1)
	}
	return this
}

func NewPopulatedContainsNestedMap_NestedMap(r randyTheproto3, easy bool) *ContainsNestedMap_NestedMap {
	this := &ContainsNestedMap_NestedMap{}
	if r.Intn(5) != 0 {
		v75 := r.Intn(10)
		this.NestedMapField = make(map[string]float64)
		for i := 0; i < v75; i++ {
			v76 := randStringTheproto3(r)
			this.NestedMapField[v76] = float64(r.Float64())
			if r.Intn(2) == 0 {
				this.NestedMapField[v76] *= -1
			}
		}
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 2)
	}
	return this
}

func NewPopulatedNotPacked(r randyTheproto3, easy bool) *NotPacked {
	this := &NotPacked{}
	v77 := r.Intn(10)
	this.Key = make([]uint64, v77)
	for i := 0; i < v77; i++ {
		this.Key[i] = uint64(uint64(r.Uint32()))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedTheproto3(r, 6)
	}
	return this
}

type randyTheproto3 interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneTheproto3(r randyTheproto3) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringTheproto3(r randyTheproto3) string {
	v78 := r.Intn(100)
	tmps := make([]rune, v78)
	for i := 0; i < v78; i++ {
		tmps[i] = randUTF8RuneTheproto3(r)
	}
	return string(tmps)
}
func randUnrecognizedTheproto3(r randyTheproto3, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldTheproto3(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldTheproto3(dAtA []byte, r randyTheproto3, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
		v79 := r.Int63()
		if r.Intn(2) == 0 {
			v79 *= -1
		}
		dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(v79))
	case 1:
		dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateTheproto3(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateTheproto3(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Message) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovTheproto3(uint64(l))
	}
	if m.Hilarity != 0 {
		n += 1 + sovTheproto3(uint64(m.Hilarity))
	}
	if m.HeightInCm != 0 {
		n += 1 + sovTheproto3(uint64(m.HeightInCm))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovTheproto3(uint64(l))
	}
	if len(m.Key) > 0 {
		l = 0
		for _, e := range m.Key {
			l += sovTheproto3(uint64(e))
		}
		n += 1 + sovTheproto3(uint64(l)) + l
	}
	if m.Nested != nil {
		l = m.Nested.Size()
		n += 1 + l + sovTheproto3(uint64(l))
	}
	if m.ResultCount != 0 {
		n += 1 + sovTheproto3(uint64(m.ResultCount))
	}
	if m.TrueScotsman {
		n += 2
	}
	if m.Score != 0 {
		n += 5
	}
	if len(m.Terrain) > 0 {
		for k, v := range m.Terrain {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTheproto3(uint64(l))
			}
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + l
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if m.Proto2Field != nil {
		l = m.Proto2Field.Size()
		n += 1 + l + sovTheproto3(uint64(l))
	}
	if len(m.Proto2Value) > 0 {
		for k, v := range m.Proto2Value {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTheproto3(uint64(l))
			}
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + l
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Nested) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Bunny)
	if l > 0 {
		n += 1 + l + sovTheproto3(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AllMaps) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.StringToDoubleMap) > 0 {
		for k, v := range m.StringToDoubleMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToFloatMap) > 0 {
		for k, v := range m.StringToFloatMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Int32Map) > 0 {
		for k, v := range m.Int32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Int64Map) > 0 {
		for k, v := range m.Int64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Uint32Map) > 0 {
		for k, v := range m.Uint32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Uint64Map) > 0 {
		for k, v := range m.Uint64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sint32Map) > 0 {
		for k, v := range m.Sint32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sint64Map) > 0 {
		for k, v := range m.Sint64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Fixed32Map) > 0 {
		for k, v := range m.Fixed32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 4 + 1 + 4
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sfixed32Map) > 0 {
		for k, v := range m.Sfixed32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 4 + 1 + 4
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Fixed64Map) > 0 {
		for k, v := range m.Fixed64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 8 + 1 + 8
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sfixed64Map) > 0 {
		for k, v := range m.Sfixed64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 8 + 1 + 8
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.BoolMap) > 0 {
		for k, v := range m.BoolMap {
			_ = k
			_ = v
			mapEntrySize := 1 + 1 + 1 + 1
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringMap) > 0 {
		for k, v := range m.StringMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v)))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToBytesMap) > 0 {
		for k, v := range m.StringToBytesMap {
			_ = k
			_ = v
			l = 0
			if len(v) > 0 {
				l = 1 + len(v) + sovTheproto3(uint64(len(v)))
			}
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToEnumMap) > 0 {
		for k, v := range m.StringToEnumMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToMsgMap) > 0 {
		for k, v := range m.StringToMsgMap {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTheproto3(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AllMapsOrdered) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.StringToDoubleMap) > 0 {
		for k, v := range m.StringToDoubleMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToFloatMap) > 0 {
		for k, v := range m.StringToFloatMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Int32Map) > 0 {
		for k, v := range m.Int32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Int64Map) > 0 {
		for k, v := range m.Int64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Uint32Map) > 0 {
		for k, v := range m.Uint32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Uint64Map) > 0 {
		for k, v := range m.Uint64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sint32Map) > 0 {
		for k, v := range m.Sint32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sint64Map) > 0 {
		for k, v := range m.Sint64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Fixed32Map) > 0 {
		for k, v := range m.Fixed32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 4 + 1 + 4
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sfixed32Map) > 0 {
		for k, v := range m.Sfixed32Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 4 + 1 + 4
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Fixed64Map) > 0 {
		for k, v := range m.Fixed64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 8 + 1 + 8
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.Sfixed64Map) > 0 {
		for k, v := range m.Sfixed64Map {
			_ = k
			_ = v
			mapEntrySize := 1 + 8 + 1 + 8
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.BoolMap) > 0 {
		for k, v := range m.BoolMap {
			_ = k
			_ = v
			mapEntrySize := 1 + 1 + 1 + 1
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringMap) > 0 {
		for k, v := range m.StringMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v)))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToBytesMap) > 0 {
		for k, v := range m.StringToBytesMap {
			_ = k
			_ = v
			l = 0
			if len(v) > 0 {
				l = 1 + len(v) + sovTheproto3(uint64(len(v)))
			}
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToEnumMap) > 0 {
		for k, v := range m.StringToEnumMap {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v))
			n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.StringToMsgMap) > 0 {
		for k, v := range m.StringToMsgMap {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTheproto3(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MessageWithMap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NameMapping) > 0 {
		for k, v := range m.NameMapping {
			_ = k
			_ = v
			mapEntrySize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v)))
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.MsgMapping) > 0 {
		for k, v := range m.MsgMapping {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTheproto3(uint64(l))
			}
			mapEntrySize := 1 + sozTheproto3(uint64(k)) + l
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if len(m.ByteMapping) > 0 {
		for k, v := range m.ByteMapping {
			_ = k
			_ = v
			l = 0
			if len(v) > 0 {
				l = 1 + len(v) + sovTheproto3(uint64(len(v)))
			}
			mapEntrySize := 1 + 1 + l
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FloatingPoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.F != 0 {
		n += 9
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Uint128Pair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Left.Size()
	n += 1 + l + sovTheproto3(uint64(l))
	if m.Right != nil {
		l = m.Right.Size()
		n += 1 + l + sovTheproto3(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ContainsNestedMap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ContainsNestedMap_NestedMap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NestedMapField) > 0 {
		for k, v := range m.NestedMapField {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
			n += mapEntrySize + 1 + sovTheproto3(uint64(mapEntrySize))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NotPacked) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Key) > 0 {
		for _, e := range m.Key {
			n += 1 + sovTheproto3(uint64(e))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovTheproto3(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTheproto3(x uint64) (n int) {
	return sovTheproto3(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Message) String() string {
	if this == nil {
		return "nil"
	}
	keysForTerrain := make([]int64, 0, len(this.Terrain))
	for k := range this.Terrain {
		keysForTerrain = append(keysForTerrain, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForTerrain)
	mapStringForTerrain := "map[int64]*Nested{"
	for _, k := range keysForTerrain {
		mapStringForTerrain += fmt.Sprintf("%v: %v,", k, this.Terrain[k])
	}
	mapStringForTerrain += "}"
	keysForProto2Value := make([]int64, 0, len(this.Proto2Value))
	for k := range this.Proto2Value {
		keysForProto2Value = append(keysForProto2Value, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForProto2Value)
	mapStringForProto2Value := "map[int64]*both.NinOptEnum{"
	for _, k := range keysForProto2Value {
		mapStringForProto2Value += fmt.Sprintf("%v: %v,", k, this.Proto2Value[k])
	}
	mapStringForProto2Value += "}"
	s := strings.Join([]string{`&Message{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Hilarity:` + fmt.Sprintf("%v", this.Hilarity) + `,`,
		`HeightInCm:` + fmt.Sprintf("%v", this.HeightInCm) + `,`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Nested:` + strings.Replace(this.Nested.String(), "Nested", "Nested", 1) + `,`,
		`ResultCount:` + fmt.Sprintf("%v", this.ResultCount) + `,`,
		`TrueScotsman:` + fmt.Sprintf("%v", this.TrueScotsman) + `,`,
		`Score:` + fmt.Sprintf("%v", this.Score) + `,`,
		`Terrain:` + mapStringForTerrain + `,`,
		`Proto2Field:` + strings.Replace(fmt.Sprintf("%v", this.Proto2Field), "NinOptNative", "both.NinOptNative", 1) + `,`,
		`Proto2Value:` + mapStringForProto2Value + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Nested) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Nested{`,
		`Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AllMaps) String() string {
	if this == nil {
		return "nil"
	}
	keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
	for k := range this.StringToDoubleMap {
		keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
	mapStringForStringToDoubleMap := "map[string]float64{"
	for _, k := range keysForStringToDoubleMap {
		mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
	}
	mapStringForStringToDoubleMap += "}"
	keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
	for k := range this.StringToFloatMap {
		keysForStringToFloatMap = append(keysForStringToFloatMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
	mapStringForStringToFloatMap := "map[string]float32{"
	for _, k := range keysForStringToFloatMap {
		mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
	}
	mapStringForStringToFloatMap += "}"
	keysForInt32Map := make([]int32, 0, len(this.Int32Map))
	for k := range this.Int32Map {
		keysForInt32Map = append(keysForInt32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
	mapStringForInt32Map := "map[int32]int32{"
	for _, k := range keysForInt32Map {
		mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
	}
	mapStringForInt32Map += "}"
	keysForInt64Map := make([]int64, 0, len(this.Int64Map))
	for k := range this.Int64Map {
		keysForInt64Map = append(keysForInt64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
	mapStringForInt64Map := "map[int64]int64{"
	for _, k := range keysForInt64Map {
		mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
	}
	mapStringForInt64Map += "}"
	keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
	for k := range this.Uint32Map {
		keysForUint32Map = append(keysForUint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
	mapStringForUint32Map := "map[uint32]uint32{"
	for _, k := range keysForUint32Map {
		mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
	}
	mapStringForUint32Map += "}"
	keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
	for k := range this.Uint64Map {
		keysForUint64Map = append(keysForUint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
	mapStringForUint64Map := "map[uint64]uint64{"
	for _, k := range keysForUint64Map {
		mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
	}
	mapStringForUint64Map += "}"
	keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
	for k := range this.Sint32Map {
		keysForSint32Map = append(keysForSint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
	mapStringForSint32Map := "map[int32]int32{"
	for _, k := range keysForSint32Map {
		mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
	}
	mapStringForSint32Map += "}"
	keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
	for k := range this.Sint64Map {
		keysForSint64Map = append(keysForSint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
	mapStringForSint64Map := "map[int64]int64{"
	for _, k := range keysForSint64Map {
		mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
	}
	mapStringForSint64Map += "}"
	keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
	for k := range this.Fixed32Map {
		keysForFixed32Map = append(keysForFixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
	mapStringForFixed32Map := "map[uint32]uint32{"
	for _, k := range keysForFixed32Map {
		mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
	}
	mapStringForFixed32Map += "}"
	keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
	for k := range this.Sfixed32Map {
		keysForSfixed32Map = append(keysForSfixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
	mapStringForSfixed32Map := "map[int32]int32{"
	for _, k := range keysForSfixed32Map {
		mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
	}
	mapStringForSfixed32Map += "}"
	keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
	for k := range this.Fixed64Map {
		keysForFixed64Map = append(keysForFixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
	mapStringForFixed64Map := "map[uint64]uint64{"
	for _, k := range keysForFixed64Map {
		mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
	}
	mapStringForFixed64Map += "}"
	keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
	for k := range this.Sfixed64Map {
		keysForSfixed64Map = append(keysForSfixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
	mapStringForSfixed64Map := "map[int64]int64{"
	for _, k := range keysForSfixed64Map {
		mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
	}
	mapStringForSfixed64Map += "}"
	keysForBoolMap := make([]bool, 0, len(this.BoolMap))
	for k := range this.BoolMap {
		keysForBoolMap = append(keysForBoolMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
	mapStringForBoolMap := "map[bool]bool{"
	for _, k := range keysForBoolMap {
		mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
	}
	mapStringForBoolMap += "}"
	keysForStringMap := make([]string, 0, len(this.StringMap))
	for k := range this.StringMap {
		keysForStringMap = append(keysForStringMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
	mapStringForStringMap := "map[string]string{"
	for _, k := range keysForStringMap {
		mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
	}
	mapStringForStringMap += "}"
	keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
	for k := range this.StringToBytesMap {
		keysForStringToBytesMap = append(keysForStringToBytesMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
	mapStringForStringToBytesMap := "map[string][]byte{"
	for _, k := range keysForStringToBytesMap {
		mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
	}
	mapStringForStringToBytesMap += "}"
	keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
	for k := range this.StringToEnumMap {
		keysForStringToEnumMap = append(keysForStringToEnumMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
	mapStringForStringToEnumMap := "map[string]MapEnum{"
	for _, k := range keysForStringToEnumMap {
		mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
	}
	mapStringForStringToEnumMap += "}"
	keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
	for k := range this.StringToMsgMap {
		keysForStringToMsgMap = append(keysForStringToMsgMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
	mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
	for _, k := range keysForStringToMsgMap {
		mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
	}
	mapStringForStringToMsgMap += "}"
	s := strings.Join([]string{`&AllMaps{`,
		`StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
		`StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
		`Int32Map:` + mapStringForInt32Map + `,`,
		`Int64Map:` + mapStringForInt64Map + `,`,
		`Uint32Map:` + mapStringForUint32Map + `,`,
		`Uint64Map:` + mapStringForUint64Map + `,`,
		`Sint32Map:` + mapStringForSint32Map + `,`,
		`Sint64Map:` + mapStringForSint64Map + `,`,
		`Fixed32Map:` + mapStringForFixed32Map + `,`,
		`Sfixed32Map:` + mapStringForSfixed32Map + `,`,
		`Fixed64Map:` + mapStringForFixed64Map + `,`,
		`Sfixed64Map:` + mapStringForSfixed64Map + `,`,
		`BoolMap:` + mapStringForBoolMap + `,`,
		`StringMap:` + mapStringForStringMap + `,`,
		`StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
		`StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
		`StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AllMapsOrdered) String() string {
	if this == nil {
		return "nil"
	}
	keysForStringToDoubleMap := make([]string, 0, len(this.StringToDoubleMap))
	for k := range this.StringToDoubleMap {
		keysForStringToDoubleMap = append(keysForStringToDoubleMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToDoubleMap)
	mapStringForStringToDoubleMap := "map[string]float64{"
	for _, k := range keysForStringToDoubleMap {
		mapStringForStringToDoubleMap += fmt.Sprintf("%v: %v,", k, this.StringToDoubleMap[k])
	}
	mapStringForStringToDoubleMap += "}"
	keysForStringToFloatMap := make([]string, 0, len(this.StringToFloatMap))
	for k := range this.StringToFloatMap {
		keysForStringToFloatMap = append(keysForStringToFloatMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToFloatMap)
	mapStringForStringToFloatMap := "map[string]float32{"
	for _, k := range keysForStringToFloatMap {
		mapStringForStringToFloatMap += fmt.Sprintf("%v: %v,", k, this.StringToFloatMap[k])
	}
	mapStringForStringToFloatMap += "}"
	keysForInt32Map := make([]int32, 0, len(this.Int32Map))
	for k := range this.Int32Map {
		keysForInt32Map = append(keysForInt32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForInt32Map)
	mapStringForInt32Map := "map[int32]int32{"
	for _, k := range keysForInt32Map {
		mapStringForInt32Map += fmt.Sprintf("%v: %v,", k, this.Int32Map[k])
	}
	mapStringForInt32Map += "}"
	keysForInt64Map := make([]int64, 0, len(this.Int64Map))
	for k := range this.Int64Map {
		keysForInt64Map = append(keysForInt64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForInt64Map)
	mapStringForInt64Map := "map[int64]int64{"
	for _, k := range keysForInt64Map {
		mapStringForInt64Map += fmt.Sprintf("%v: %v,", k, this.Int64Map[k])
	}
	mapStringForInt64Map += "}"
	keysForUint32Map := make([]uint32, 0, len(this.Uint32Map))
	for k := range this.Uint32Map {
		keysForUint32Map = append(keysForUint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForUint32Map)
	mapStringForUint32Map := "map[uint32]uint32{"
	for _, k := range keysForUint32Map {
		mapStringForUint32Map += fmt.Sprintf("%v: %v,", k, this.Uint32Map[k])
	}
	mapStringForUint32Map += "}"
	keysForUint64Map := make([]uint64, 0, len(this.Uint64Map))
	for k := range this.Uint64Map {
		keysForUint64Map = append(keysForUint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForUint64Map)
	mapStringForUint64Map := "map[uint64]uint64{"
	for _, k := range keysForUint64Map {
		mapStringForUint64Map += fmt.Sprintf("%v: %v,", k, this.Uint64Map[k])
	}
	mapStringForUint64Map += "}"
	keysForSint32Map := make([]int32, 0, len(this.Sint32Map))
	for k := range this.Sint32Map {
		keysForSint32Map = append(keysForSint32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSint32Map)
	mapStringForSint32Map := "map[int32]int32{"
	for _, k := range keysForSint32Map {
		mapStringForSint32Map += fmt.Sprintf("%v: %v,", k, this.Sint32Map[k])
	}
	mapStringForSint32Map += "}"
	keysForSint64Map := make([]int64, 0, len(this.Sint64Map))
	for k := range this.Sint64Map {
		keysForSint64Map = append(keysForSint64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSint64Map)
	mapStringForSint64Map := "map[int64]int64{"
	for _, k := range keysForSint64Map {
		mapStringForSint64Map += fmt.Sprintf("%v: %v,", k, this.Sint64Map[k])
	}
	mapStringForSint64Map += "}"
	keysForFixed32Map := make([]uint32, 0, len(this.Fixed32Map))
	for k := range this.Fixed32Map {
		keysForFixed32Map = append(keysForFixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint32s(keysForFixed32Map)
	mapStringForFixed32Map := "map[uint32]uint32{"
	for _, k := range keysForFixed32Map {
		mapStringForFixed32Map += fmt.Sprintf("%v: %v,", k, this.Fixed32Map[k])
	}
	mapStringForFixed32Map += "}"
	keysForSfixed32Map := make([]int32, 0, len(this.Sfixed32Map))
	for k := range this.Sfixed32Map {
		keysForSfixed32Map = append(keysForSfixed32Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForSfixed32Map)
	mapStringForSfixed32Map := "map[int32]int32{"
	for _, k := range keysForSfixed32Map {
		mapStringForSfixed32Map += fmt.Sprintf("%v: %v,", k, this.Sfixed32Map[k])
	}
	mapStringForSfixed32Map += "}"
	keysForFixed64Map := make([]uint64, 0, len(this.Fixed64Map))
	for k := range this.Fixed64Map {
		keysForFixed64Map = append(keysForFixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Uint64s(keysForFixed64Map)
	mapStringForFixed64Map := "map[uint64]uint64{"
	for _, k := range keysForFixed64Map {
		mapStringForFixed64Map += fmt.Sprintf("%v: %v,", k, this.Fixed64Map[k])
	}
	mapStringForFixed64Map += "}"
	keysForSfixed64Map := make([]int64, 0, len(this.Sfixed64Map))
	for k := range this.Sfixed64Map {
		keysForSfixed64Map = append(keysForSfixed64Map, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForSfixed64Map)
	mapStringForSfixed64Map := "map[int64]int64{"
	for _, k := range keysForSfixed64Map {
		mapStringForSfixed64Map += fmt.Sprintf("%v: %v,", k, this.Sfixed64Map[k])
	}
	mapStringForSfixed64Map += "}"
	keysForBoolMap := make([]bool, 0, len(this.BoolMap))
	for k := range this.BoolMap {
		keysForBoolMap = append(keysForBoolMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Bools(keysForBoolMap)
	mapStringForBoolMap := "map[bool]bool{"
	for _, k := range keysForBoolMap {
		mapStringForBoolMap += fmt.Sprintf("%v: %v,", k, this.BoolMap[k])
	}
	mapStringForBoolMap += "}"
	keysForStringMap := make([]string, 0, len(this.StringMap))
	for k := range this.StringMap {
		keysForStringMap = append(keysForStringMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringMap)
	mapStringForStringMap := "map[string]string{"
	for _, k := range keysForStringMap {
		mapStringForStringMap += fmt.Sprintf("%v: %v,", k, this.StringMap[k])
	}
	mapStringForStringMap += "}"
	keysForStringToBytesMap := make([]string, 0, len(this.StringToBytesMap))
	for k := range this.StringToBytesMap {
		keysForStringToBytesMap = append(keysForStringToBytesMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToBytesMap)
	mapStringForStringToBytesMap := "map[string][]byte{"
	for _, k := range keysForStringToBytesMap {
		mapStringForStringToBytesMap += fmt.Sprintf("%v: %v,", k, this.StringToBytesMap[k])
	}
	mapStringForStringToBytesMap += "}"
	keysForStringToEnumMap := make([]string, 0, len(this.StringToEnumMap))
	for k := range this.StringToEnumMap {
		keysForStringToEnumMap = append(keysForStringToEnumMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToEnumMap)
	mapStringForStringToEnumMap := "map[string]MapEnum{"
	for _, k := range keysForStringToEnumMap {
		mapStringForStringToEnumMap += fmt.Sprintf("%v: %v,", k, this.StringToEnumMap[k])
	}
	mapStringForStringToEnumMap += "}"
	keysForStringToMsgMap := make([]string, 0, len(this.StringToMsgMap))
	for k := range this.StringToMsgMap {
		keysForStringToMsgMap = append(keysForStringToMsgMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForStringToMsgMap)
	mapStringForStringToMsgMap := "map[string]*FloatingPoint{"
	for _, k := range keysForStringToMsgMap {
		mapStringForStringToMsgMap += fmt.Sprintf("%v: %v,", k, this.StringToMsgMap[k])
	}
	mapStringForStringToMsgMap += "}"
	s := strings.Join([]string{`&AllMapsOrdered{`,
		`StringToDoubleMap:` + mapStringForStringToDoubleMap + `,`,
		`StringToFloatMap:` + mapStringForStringToFloatMap + `,`,
		`Int32Map:` + mapStringForInt32Map + `,`,
		`Int64Map:` + mapStringForInt64Map + `,`,
		`Uint32Map:` + mapStringForUint32Map + `,`,
		`Uint64Map:` + mapStringForUint64Map + `,`,
		`Sint32Map:` + mapStringForSint32Map + `,`,
		`Sint64Map:` + mapStringForSint64Map + `,`,
		`Fixed32Map:` + mapStringForFixed32Map + `,`,
		`Sfixed32Map:` + mapStringForSfixed32Map + `,`,
		`Fixed64Map:` + mapStringForFixed64Map + `,`,
		`Sfixed64Map:` + mapStringForSfixed64Map + `,`,
		`BoolMap:` + mapStringForBoolMap + `,`,
		`StringMap:` + mapStringForStringMap + `,`,
		`StringToBytesMap:` + mapStringForStringToBytesMap + `,`,
		`StringToEnumMap:` + mapStringForStringToEnumMap + `,`,
		`StringToMsgMap:` + mapStringForStringToMsgMap + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *MessageWithMap) String() string {
	if this == nil {
		return "nil"
	}
	keysForNameMapping := make([]int32, 0, len(this.NameMapping))
	for k := range this.NameMapping {
		keysForNameMapping = append(keysForNameMapping, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNameMapping)
	mapStringForNameMapping := "map[int32]string{"
	for _, k := range keysForNameMapping {
		mapStringForNameMapping += fmt.Sprintf("%v: %v,", k, this.NameMapping[k])
	}
	mapStringForNameMapping += "}"
	keysForMsgMapping := make([]int64, 0, len(this.MsgMapping))
	for k := range this.MsgMapping {
		keysForMsgMapping = append(keysForMsgMapping, k)
	}
	github_com_gogo_protobuf_sortkeys.Int64s(keysForMsgMapping)
	mapStringForMsgMapping := "map[int64]*FloatingPoint{"
	for _, k := range keysForMsgMapping {
		mapStringForMsgMapping += fmt.Sprintf("%v: %v,", k, this.MsgMapping[k])
	}
	mapStringForMsgMapping += "}"
	keysForByteMapping := make([]bool, 0, len(this.ByteMapping))
	for k := range this.ByteMapping {
		keysForByteMapping = append(keysForByteMapping, k)
	}
	github_com_gogo_protobuf_sortkeys.Bools(keysForByteMapping)
	mapStringForByteMapping := "map[bool][]byte{"
	for _, k := range keysForByteMapping {
		mapStringForByteMapping += fmt.Sprintf("%v: %v,", k, this.ByteMapping[k])
	}
	mapStringForByteMapping += "}"
	s := strings.Join([]string{`&MessageWithMap{`,
		`NameMapping:` + mapStringForNameMapping + `,`,
		`MsgMapping:` + mapStringForMsgMapping + `,`,
		`ByteMapping:` + mapStringForByteMapping + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FloatingPoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FloatingPoint{`,
		`F:` + fmt.Sprintf("%v", this.F) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Uint128Pair) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Uint128Pair{`,
		`Left:` + fmt.Sprintf("%v", this.Left) + `,`,
		`Right:` + fmt.Sprintf("%v", this.Right) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainsNestedMap) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ContainsNestedMap{`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainsNestedMap_NestedMap) String() string {
	if this == nil {
		return "nil"
	}
	keysForNestedMapField := make([]string, 0, len(this.NestedMapField))
	for k := range this.NestedMapField {
		keysForNestedMapField = append(keysForNestedMapField, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForNestedMapField)
	mapStringForNestedMapField := "map[string]float64{"
	for _, k := range keysForNestedMapField {
		mapStringForNestedMapField += fmt.Sprintf("%v: %v,", k, this.NestedMapField[k])
	}
	mapStringForNestedMapField += "}"
	s := strings.Join([]string{`&ContainsNestedMap_NestedMap{`,
		`NestedMapField:` + mapStringForNestedMapField + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NotPacked) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NotPacked{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringTheproto3(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Message) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				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 ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hilarity", wireType)
			}
			m.Hilarity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hilarity |= Message_Humour(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeightInCm", wireType)
			}
			m.HeightInCm = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HeightInCm |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Key = append(m.Key, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTheproto3
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTheproto3
				}
				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.Key) == 0 {
					m.Key = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Key = append(m.Key, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nested", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Nested == nil {
				m.Nested = &Nested{}
			}
			if err := m.Nested.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultCount", wireType)
			}
			m.ResultCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultCount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrueScotsman", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TrueScotsman = bool(v != 0)
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Score = float32(math.Float32frombits(v))
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Terrain", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Terrain == nil {
				m.Terrain = make(map[int64]*Nested)
			}
			var mapkey int64
			var mapvalue *Nested
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Nested{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Terrain[mapkey] = mapvalue
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proto2Field", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proto2Field == nil {
				m.Proto2Field = &both.NinOptNative{}
			}
			if err := m.Proto2Field.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proto2Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proto2Value == nil {
				m.Proto2Value = make(map[int64]*both.NinOptEnum)
			}
			var mapkey int64
			var mapvalue *both.NinOptEnum
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &both.NinOptEnum{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Proto2Value[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Nested) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: Nested: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Nested: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bunny", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				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 ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Bunny = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AllMaps) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: AllMaps: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AllMaps: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToDoubleMap == nil {
				m.StringToDoubleMap = make(map[string]float64)
			}
			var mapkey string
			var mapvalue float64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					mapvalue = math.Float64frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToDoubleMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToFloatMap == nil {
				m.StringToFloatMap = make(map[string]float32)
			}
			var mapkey string
			var mapvalue float32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					mapvalue = math.Float32frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToFloatMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Int32Map == nil {
				m.Int32Map = make(map[int32]int32)
			}
			var mapkey int32
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Int32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Int64Map == nil {
				m.Int64Map = make(map[int64]int64)
			}
			var mapkey int64
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Int64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Uint32Map == nil {
				m.Uint32Map = make(map[uint32]uint32)
			}
			var mapkey uint32
			var mapvalue uint32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Uint32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Uint64Map == nil {
				m.Uint64Map = make(map[uint64]uint64)
			}
			var mapkey uint64
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Uint64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sint32Map == nil {
				m.Sint32Map = make(map[int32]int32)
			}
			var mapkey int32
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
					mapkey = int32(mapkeytemp)
				} else if fieldNum == 2 {
					var mapvaluetemp int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
					mapvalue = int32(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sint32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sint64Map == nil {
				m.Sint64Map = make(map[int64]int64)
			}
			var mapkey int64
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
					mapkey = int64(mapkeytemp)
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
					mapvalue = int64(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sint64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fixed32Map == nil {
				m.Fixed32Map = make(map[uint32]uint32)
			}
			var mapkey uint32
			var mapvalue uint32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else if fieldNum == 2 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Fixed32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sfixed32Map == nil {
				m.Sfixed32Map = make(map[int32]int32)
			}
			var mapkey int32
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else if fieldNum == 2 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sfixed32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fixed64Map == nil {
				m.Fixed64Map = make(map[uint64]uint64)
			}
			var mapkey uint64
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Fixed64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sfixed64Map == nil {
				m.Sfixed64Map = make(map[int64]int64)
			}
			var mapkey int64
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sfixed64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BoolMap == nil {
				m.BoolMap = make(map[bool]bool)
			}
			var mapkey bool
			var mapvalue bool
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkey = bool(mapkeytemp != 0)
				} else if fieldNum == 2 {
					var mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.BoolMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringMap == nil {
				m.StringMap = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToBytesMap == nil {
				m.StringToBytesMap = make(map[string][]byte)
			}
			var mapkey string
			mapvalue := []byte{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapbyteLen uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapbyteLen |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intMapbyteLen := int(mapbyteLen)
					if intMapbyteLen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postbytesIndex := iNdEx + intMapbyteLen
					if postbytesIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postbytesIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = make([]byte, mapbyteLen)
					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
					iNdEx = postbytesIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToBytesMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToEnumMap == nil {
				m.StringToEnumMap = make(map[string]MapEnum)
			}
			var mapkey string
			var mapvalue MapEnum
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= MapEnum(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToEnumMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToMsgMap == nil {
				m.StringToMsgMap = make(map[string]*FloatingPoint)
			}
			var mapkey string
			var mapvalue *FloatingPoint
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &FloatingPoint{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToMsgMap[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AllMapsOrdered) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: AllMapsOrdered: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AllMapsOrdered: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToDoubleMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToDoubleMap == nil {
				m.StringToDoubleMap = make(map[string]float64)
			}
			var mapkey string
			var mapvalue float64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					mapvalue = math.Float64frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToDoubleMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToFloatMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToFloatMap == nil {
				m.StringToFloatMap = make(map[string]float32)
			}
			var mapkey string
			var mapvalue float32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					mapvalue = math.Float32frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToFloatMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Int32Map == nil {
				m.Int32Map = make(map[int32]int32)
			}
			var mapkey int32
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Int32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Int64Map == nil {
				m.Int64Map = make(map[int64]int64)
			}
			var mapkey int64
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Int64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Uint32Map == nil {
				m.Uint32Map = make(map[uint32]uint32)
			}
			var mapkey uint32
			var mapvalue uint32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Uint32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Uint64Map == nil {
				m.Uint64Map = make(map[uint64]uint64)
			}
			var mapkey uint64
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Uint64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sint32Map == nil {
				m.Sint32Map = make(map[int32]int32)
			}
			var mapkey int32
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkeytemp = int32((uint32(mapkeytemp) >> 1) ^ uint32(((mapkeytemp&1)<<31)>>31))
					mapkey = int32(mapkeytemp)
				} else if fieldNum == 2 {
					var mapvaluetemp int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvaluetemp = int32((uint32(mapvaluetemp) >> 1) ^ uint32(((mapvaluetemp&1)<<31)>>31))
					mapvalue = int32(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sint32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sint64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sint64Map == nil {
				m.Sint64Map = make(map[int64]int64)
			}
			var mapkey int64
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
					mapkey = int64(mapkeytemp)
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvaluetemp = (mapvaluetemp >> 1) ^ uint64((int64(mapvaluetemp&1)<<63)>>63)
					mapvalue = int64(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sint64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fixed32Map == nil {
				m.Fixed32Map = make(map[uint32]uint32)
			}
			var mapkey uint32
			var mapvalue uint32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else if fieldNum == 2 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Fixed32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed32Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sfixed32Map == nil {
				m.Sfixed32Map = make(map[int32]int32)
			}
			var mapkey int32
			var mapvalue int32
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else if fieldNum == 2 {
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sfixed32Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fixed64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Fixed64Map == nil {
				m.Fixed64Map = make(map[uint64]uint64)
			}
			var mapkey uint64
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Fixed64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sfixed64Map", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Sfixed64Map == nil {
				m.Sfixed64Map = make(map[int64]int64)
			}
			var mapkey int64
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else if fieldNum == 2 {
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = int64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Sfixed64Map[mapkey] = mapvalue
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BoolMap == nil {
				m.BoolMap = make(map[bool]bool)
			}
			var mapkey bool
			var mapvalue bool
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkey = bool(mapkeytemp != 0)
				} else if fieldNum == 2 {
					var mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.BoolMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringMap == nil {
				m.StringMap = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToBytesMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToBytesMap == nil {
				m.StringToBytesMap = make(map[string][]byte)
			}
			var mapkey string
			mapvalue := []byte{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapbyteLen uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapbyteLen |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intMapbyteLen := int(mapbyteLen)
					if intMapbyteLen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postbytesIndex := iNdEx + intMapbyteLen
					if postbytesIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postbytesIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = make([]byte, mapbyteLen)
					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
					iNdEx = postbytesIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToBytesMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToEnumMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToEnumMap == nil {
				m.StringToEnumMap = make(map[string]MapEnum)
			}
			var mapkey string
			var mapvalue MapEnum
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= MapEnum(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToEnumMap[mapkey] = mapvalue
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringToMsgMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StringToMsgMap == nil {
				m.StringToMsgMap = make(map[string]*FloatingPoint)
			}
			var mapkey string
			var mapvalue *FloatingPoint
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &FloatingPoint{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.StringToMsgMap[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageWithMap) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: MessageWithMap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageWithMap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NameMapping", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NameMapping == nil {
				m.NameMapping = make(map[int32]string)
			}
			var mapkey int32
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NameMapping[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgMapping", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MsgMapping == nil {
				m.MsgMapping = make(map[int64]*FloatingPoint)
			}
			var mapkey int64
			var mapvalue *FloatingPoint
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkeytemp = (mapkeytemp >> 1) ^ uint64((int64(mapkeytemp&1)<<63)>>63)
					mapkey = int64(mapkeytemp)
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &FloatingPoint{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MsgMapping[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ByteMapping", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ByteMapping == nil {
				m.ByteMapping = make(map[bool][]byte)
			}
			var mapkey bool
			mapvalue := []byte{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var mapkeytemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkeytemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapkey = bool(mapkeytemp != 0)
				} else if fieldNum == 2 {
					var mapbyteLen uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapbyteLen |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intMapbyteLen := int(mapbyteLen)
					if intMapbyteLen < 0 {
						return ErrInvalidLengthTheproto3
					}
					postbytesIndex := iNdEx + intMapbyteLen
					if postbytesIndex < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postbytesIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = make([]byte, mapbyteLen)
					copy(mapvalue, dAtA[iNdEx:postbytesIndex])
					iNdEx = postbytesIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ByteMapping[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FloatingPoint) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: FloatingPoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FloatingPoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field F", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.F = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Uint128Pair) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: Uint128Pair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Uint128Pair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_gogo_protobuf_test_custom.Uint128
			m.Right = &v
			if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainsNestedMap) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: ContainsNestedMap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContainsNestedMap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ContainsNestedMap_NestedMap) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: NestedMap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NestedMap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NestedMapField", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTheproto3
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTheproto3
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NestedMapField == nil {
				m.NestedMapField = make(map[string]float64)
			}
			var mapkey string
			var mapvalue float64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTheproto3
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapvaluetemp uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					mapvaluetemp = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					mapvalue = math.Float64frombits(mapvaluetemp)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTheproto3(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTheproto3
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NestedMapField[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NotPacked) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTheproto3
			}
			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: NotPacked: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NotPacked: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 5:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Key = append(m.Key, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTheproto3
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTheproto3
				}
				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.Key) == 0 {
					m.Key = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTheproto3
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Key = append(m.Key, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTheproto3(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTheproto3
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTheproto3
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTheproto3
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTheproto3
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTheproto3        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTheproto3          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTheproto3 = fmt.Errorf("proto: unexpected end of group")
)