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

/*
	Package theproto3 is a generated protocol buffer package.

	It is generated from these files:
		combos/both/theproto3.proto

	It has these top-level messages:
		Message
		Nested
		AllMaps
		AllMapsOrdered
		MessageWithMap
		FloatingPoint
		Uint128Pair
		ContainsNestedMap
		NotPacked
*/
package theproto3

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import test "github.com/gogo/protobuf/test/combos/both"

import github_com_gogo_protobuf_test_custom "github.com/gogo/protobuf/test/custom"

import github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import compress_gzip "compress/gzip"
import bytes "bytes"
import io_ioutil "io/ioutil"

import strconv "strconv"

import strings "strings"
import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"

import io "io"

// 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.GoGoProtoPackageIsVersion2 // 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 fileDescriptorTheproto3, []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 fileDescriptorTheproto3, []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" json:"key,omitempty"`
	Nested       *Nested                    `protobuf:"bytes,6,opt,name=nested" json:"nested,omitempty"`
	Terrain      map[int64]*Nested          `protobuf:"bytes,10,rep,name=terrain" json:"terrain,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	Proto2Field  *test.NinOptNative         `protobuf:"bytes,11,opt,name=proto2_field,json=proto2Field" json:"proto2_field,omitempty"`
	Proto2Value  map[int64]*test.NinOptEnum `protobuf:"bytes,13,rep,name=proto2_value,json=proto2Value" json:"proto2_value,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *Message) Reset()                    { *m = Message{} }
func (*Message) ProtoMessage()               {}
func (*Message) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{0} }

type Nested struct {
	Bunny string `protobuf:"bytes,1,opt,name=bunny,proto3" json:"bunny,omitempty"`
}

func (m *Nested) Reset()                    { *m = Nested{} }
func (*Nested) ProtoMessage()               {}
func (*Nested) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{1} }

type AllMaps struct {
	StringToDoubleMap map[string]float64        `protobuf:"bytes,1,rep,name=StringToDoubleMap" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *AllMaps) Reset()                    { *m = AllMaps{} }
func (*AllMaps) ProtoMessage()               {}
func (*AllMaps) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{2} }

type AllMapsOrdered struct {
	StringToDoubleMap map[string]float64        `protobuf:"bytes,1,rep,name=StringToDoubleMap" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" 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" json:"StringToMsgMap,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
}

func (m *AllMapsOrdered) Reset()                    { *m = AllMapsOrdered{} }
func (*AllMapsOrdered) ProtoMessage()               {}
func (*AllMapsOrdered) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{3} }

type MessageWithMap struct {
	NameMapping map[int32]string         `protobuf:"bytes,1,rep,name=name_mapping,json=nameMapping" 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" json:"msg_mapping,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
	ByteMapping map[bool][]byte          `protobuf:"bytes,3,rep,name=byte_mapping,json=byteMapping" json:"byte_mapping,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *MessageWithMap) Reset()                    { *m = MessageWithMap{} }
func (*MessageWithMap) ProtoMessage()               {}
func (*MessageWithMap) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{4} }

type FloatingPoint struct {
	F float64 `protobuf:"fixed64,1,opt,name=f,proto3" json:"f,omitempty"`
}

func (m *FloatingPoint) Reset()                    { *m = FloatingPoint{} }
func (*FloatingPoint) ProtoMessage()               {}
func (*FloatingPoint) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{5} }

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"`
}

func (m *Uint128Pair) Reset()                    { *m = Uint128Pair{} }
func (*Uint128Pair) ProtoMessage()               {}
func (*Uint128Pair) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{6} }

type ContainsNestedMap struct {
}

func (m *ContainsNestedMap) Reset()                    { *m = ContainsNestedMap{} }
func (*ContainsNestedMap) ProtoMessage()               {}
func (*ContainsNestedMap) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{7} }

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

func (m *ContainsNestedMap_NestedMap) Reset()      { *m = ContainsNestedMap_NestedMap{} }
func (*ContainsNestedMap_NestedMap) ProtoMessage() {}
func (*ContainsNestedMap_NestedMap) Descriptor() ([]byte, []int) {
	return fileDescriptorTheproto3, []int{7, 0}
}

type NotPacked struct {
	Key []uint64 `protobuf:"varint,5,rep,name=key" json:"key,omitempty"`
}

func (m *NotPacked) Reset()                    { *m = NotPacked{} }
func (*NotPacked) ProtoMessage()               {}
func (*NotPacked) Descriptor() ([]byte, []int) { return fileDescriptorTheproto3, []int{8} }

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

	that1, ok := that.(*Message)
	if !ok {
		that2, ok := that.(Message)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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)
	}
	return nil
}
func (this *Nested) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Nested)
	if !ok {
		that2, ok := that.(Nested)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Bunny != that1.Bunny {
		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])
		}
	}
	return nil
}
func (this *AllMaps) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*AllMaps)
	if !ok {
		that2, ok := that.(AllMaps)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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])
		}
	}
	return nil
}
func (this *AllMapsOrdered) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*AllMapsOrdered)
	if !ok {
		that2, ok := that.(AllMapsOrdered)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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])
		}
	}
	return nil
}
func (this *MessageWithMap) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*MessageWithMap)
	if !ok {
		that2, ok := that.(MessageWithMap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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)
	}
	return nil
}
func (this *FloatingPoint) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*FloatingPoint)
	if !ok {
		that2, ok := that.(FloatingPoint)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.F != that1.F {
		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)
	}
	return nil
}
func (this *Uint128Pair) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Uint128Pair)
	if !ok {
		that2, ok := that.(Uint128Pair)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
	}
	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")
	}
	return nil
}
func (this *ContainsNestedMap) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ContainsNestedMap)
	if !ok {
		that2, ok := that.(ContainsNestedMap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		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])
		}
	}
	return nil
}
func (this *ContainsNestedMap_NestedMap) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ContainsNestedMap_NestedMap)
	if !ok {
		that2, ok := that.(ContainsNestedMap_NestedMap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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])
		}
	}
	return nil
}
func (this *NotPacked) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*NotPacked)
	if !ok {
		that2, ok := that.(NotPacked)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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
		}
	}
	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() *test.NinOptNative
	GetProto2Value() map[int64]*test.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() *test.NinOptNative {
	return this.Proto2Field
}

func (this *Message) GetProto2Value() map[int64]*test.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]*test.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")
	}
	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")
	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")
	}
	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")
	}
	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")
	}
	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")
	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")
	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{")
	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")
	}
	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")
	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.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Message) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Hilarity != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(m.Hilarity))
	}
	if m.HeightInCm != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(m.HeightInCm))
	}
	if len(m.Data) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	if len(m.Key) > 0 {
		dAtA2 := make([]byte, len(m.Key)*10)
		var j1 int
		for _, num := range m.Key {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		dAtA[i] = 0x2a
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	if m.Nested != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(m.Nested.Size()))
		n3, err := m.Nested.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.ResultCount != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(m.ResultCount))
	}
	if m.TrueScotsman {
		dAtA[i] = 0x40
		i++
		if m.TrueScotsman {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Score != 0 {
		dAtA[i] = 0x4d
		i++
		i = encodeFixed32Theproto3(dAtA, i, uint32(math.Float32bits(float32(m.Score))))
	}
	if len(m.Terrain) > 0 {
		for k := range m.Terrain {
			dAtA[i] = 0x52
			i++
			v := m.Terrain[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTheproto3(uint64(msgSize))
			}
			mapSize := 1 + sovTheproto3(uint64(k)) + msgSize
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTheproto3(dAtA, i, uint64(v.Size()))
				n4, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n4
			}
		}
	}
	if m.Proto2Field != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(m.Proto2Field.Size()))
		n5, err := m.Proto2Field.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if len(m.Proto2Value) > 0 {
		for k := range m.Proto2Value {
			dAtA[i] = 0x6a
			i++
			v := m.Proto2Value[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTheproto3(uint64(msgSize))
			}
			mapSize := 1 + sovTheproto3(uint64(k)) + msgSize
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTheproto3(dAtA, i, uint64(v.Size()))
				n6, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n6
			}
		}
	}
	return i, nil
}

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

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

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

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

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

func (m *AllMapsOrdered) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	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 _, k := range keysForStringToDoubleMap {
			dAtA[i] = 0xa
			i++
			v := m.StringToDoubleMap[string(k)]
			mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x11
			i++
			i = encodeFixed64Theproto3(dAtA, i, uint64(math.Float64bits(float64(v))))
		}
	}
	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 _, k := range keysForStringToFloatMap {
			dAtA[i] = 0x12
			i++
			v := m.StringToFloatMap[string(k)]
			mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 4
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x15
			i++
			i = encodeFixed32Theproto3(dAtA, i, uint32(math.Float32bits(float32(v))))
		}
	}
	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 _, k := range keysForInt32Map {
			dAtA[i] = 0x1a
			i++
			v := m.Int32Map[int32(k)]
			mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
		}
	}
	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 _, k := range keysForInt64Map {
			dAtA[i] = 0x22
			i++
			v := m.Int64Map[int64(k)]
			mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
		}
	}
	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 _, k := range keysForUint32Map {
			dAtA[i] = 0x2a
			i++
			v := m.Uint32Map[uint32(k)]
			mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
		}
	}
	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 _, k := range keysForUint64Map {
			dAtA[i] = 0x32
			i++
			v := m.Uint64Map[uint64(k)]
			mapSize := 1 + sovTheproto3(uint64(k)) + 1 + sovTheproto3(uint64(v))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
		}
	}
	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 _, k := range keysForSint32Map {
			dAtA[i] = 0x3a
			i++
			v := m.Sint32Map[int32(k)]
			mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64((uint32(k)<<1)^uint32((k>>31))))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64((uint32(v)<<1)^uint32((v>>31))))
		}
	}
	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 _, k := range keysForSint64Map {
			dAtA[i] = 0x42
			i++
			v := m.Sint64Map[int64(k)]
			mapSize := 1 + sozTheproto3(uint64(k)) + 1 + sozTheproto3(uint64(v))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(k)<<1)^uint64((k>>63))))
			dAtA[i] = 0x10
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(v)<<1)^uint64((v>>63))))
		}
	}
	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 _, k := range keysForFixed32Map {
			dAtA[i] = 0x4a
			i++
			v := m.Fixed32Map[uint32(k)]
			mapSize := 1 + 4 + 1 + 4
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xd
			i++
			i = encodeFixed32Theproto3(dAtA, i, uint32(k))
			dAtA[i] = 0x15
			i++
			i = encodeFixed32Theproto3(dAtA, i, uint32(v))
		}
	}
	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 _, k := range keysForSfixed32Map {
			dAtA[i] = 0x52
			i++
			v := m.Sfixed32Map[int32(k)]
			mapSize := 1 + 4 + 1 + 4
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xd
			i++
			i = encodeFixed32Theproto3(dAtA, i, uint32(k))
			dAtA[i] = 0x15
			i++
			i = encodeFixed32Theproto3(dAtA, i, uint32(v))
		}
	}
	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 _, k := range keysForFixed64Map {
			dAtA[i] = 0x5a
			i++
			v := m.Fixed64Map[uint64(k)]
			mapSize := 1 + 8 + 1 + 8
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x9
			i++
			i = encodeFixed64Theproto3(dAtA, i, uint64(k))
			dAtA[i] = 0x11
			i++
			i = encodeFixed64Theproto3(dAtA, i, uint64(v))
		}
	}
	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 _, k := range keysForSfixed64Map {
			dAtA[i] = 0x62
			i++
			v := m.Sfixed64Map[int64(k)]
			mapSize := 1 + 8 + 1 + 8
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x9
			i++
			i = encodeFixed64Theproto3(dAtA, i, uint64(k))
			dAtA[i] = 0x11
			i++
			i = encodeFixed64Theproto3(dAtA, i, uint64(v))
		}
	}
	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 _, k := range keysForBoolMap {
			dAtA[i] = 0x6a
			i++
			v := m.BoolMap[bool(k)]
			mapSize := 1 + 1 + 1 + 1
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			if k {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
			dAtA[i] = 0x10
			i++
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
		}
	}
	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 _, k := range keysForStringMap {
			dAtA[i] = 0x72
			i++
			v := m.StringMap[string(k)]
			mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + len(v) + sovTheproto3(uint64(len(v)))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	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 _, k := range keysForStringToBytesMap {
			dAtA[i] = 0x7a
			i++
			v := m.StringToBytesMap[string(k)]
			byteSize := 0
			if len(v) > 0 {
				byteSize = 1 + len(v) + sovTheproto3(uint64(len(v)))
			}
			mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + byteSize
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if len(v) > 0 {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
				i += copy(dAtA[i:], v)
			}
		}
	}
	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 _, k := range keysForStringToEnumMap {
			dAtA[i] = 0x82
			i++
			dAtA[i] = 0x1
			i++
			v := m.StringToEnumMap[string(k)]
			mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + sovTheproto3(uint64(v))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(v))
		}
	}
	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 _, k := range keysForStringToMsgMap {
			dAtA[i] = 0x8a
			i++
			dAtA[i] = 0x1
			i++
			v := m.StringToMsgMap[string(k)]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTheproto3(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + msgSize
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTheproto3(dAtA, i, uint64(v.Size()))
				n8, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n8
			}
		}
	}
	return i, nil
}

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

func (m *MessageWithMap) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NameMapping) > 0 {
		for k := range m.NameMapping {
			dAtA[i] = 0xa
			i++
			v := m.NameMapping[k]
			mapSize := 1 + sovTheproto3(uint64(k)) + 1 + len(v) + sovTheproto3(uint64(len(v)))
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if len(m.MsgMapping) > 0 {
		for k := range m.MsgMapping {
			dAtA[i] = 0x12
			i++
			v := m.MsgMapping[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovTheproto3(uint64(msgSize))
			}
			mapSize := 1 + sozTheproto3(uint64(k)) + msgSize
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64((uint64(k)<<1)^uint64((k>>63))))
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTheproto3(dAtA, i, uint64(v.Size()))
				n9, err := v.MarshalTo(dAtA[i:])
				if err != nil {
					return 0, err
				}
				i += n9
			}
		}
	}
	if len(m.ByteMapping) > 0 {
		for k := range m.ByteMapping {
			dAtA[i] = 0x1a
			i++
			v := m.ByteMapping[k]
			byteSize := 0
			if len(v) > 0 {
				byteSize = 1 + len(v) + sovTheproto3(uint64(len(v)))
			}
			mapSize := 1 + 1 + byteSize
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			if k {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
			if len(v) > 0 {
				dAtA[i] = 0x12
				i++
				i = encodeVarintTheproto3(dAtA, i, uint64(len(v)))
				i += copy(dAtA[i:], v)
			}
		}
	}
	return i, nil
}

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

func (m *FloatingPoint) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.F != 0 {
		dAtA[i] = 0x9
		i++
		i = encodeFixed64Theproto3(dAtA, i, uint64(math.Float64bits(float64(m.F))))
	}
	return i, nil
}

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

func (m *Uint128Pair) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintTheproto3(dAtA, i, uint64(m.Left.Size()))
	n10, err := m.Left.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n10
	if m.Right != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTheproto3(dAtA, i, uint64(m.Right.Size()))
		n11, err := m.Right.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}

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

func (m *ContainsNestedMap) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *ContainsNestedMap_NestedMap) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NestedMapField) > 0 {
		for k := range m.NestedMapField {
			dAtA[i] = 0xa
			i++
			v := m.NestedMapField[k]
			mapSize := 1 + len(k) + sovTheproto3(uint64(len(k))) + 1 + 8
			i = encodeVarintTheproto3(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x11
			i++
			i = encodeFixed64Theproto3(dAtA, i, uint64(math.Float64bits(float64(v))))
		}
	}
	return i, nil
}

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

func (m *NotPacked) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		for _, num := range m.Key {
			dAtA[i] = 0x28
			i++
			i = encodeVarintTheproto3(dAtA, i, uint64(num))
		}
	}
	return i, nil
}

func encodeFixed64Theproto3(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Theproto3(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintTheproto3(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
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(10) != 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(10) != 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(10) != 0 {
		this.Proto2Field = test.NewPopulatedNinOptNative(r, easy)
	}
	if r.Intn(10) != 0 {
		v4 := r.Intn(10)
		this.Proto2Value = make(map[int64]*test.NinOptEnum)
		for i := 0; i < v4; i++ {
			this.Proto2Value[int64(r.Int63())] = test.NewPopulatedNinOptEnum(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

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

func NewPopulatedAllMaps(r randyTheproto3, easy bool) *AllMaps {
	this := &AllMaps{}
	if r.Intn(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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 {
	}
	return this
}

func NewPopulatedAllMapsOrdered(r randyTheproto3, easy bool) *AllMapsOrdered {
	this := &AllMapsOrdered{}
	if r.Intn(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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(10) != 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 {
	}
	return this
}

func NewPopulatedMessageWithMap(r randyTheproto3, easy bool) *MessageWithMap {
	this := &MessageWithMap{}
	if r.Intn(10) != 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(10) != 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(10) != 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 {
	}
	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 {
	}
	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 {
	}
	return this
}

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

func NewPopulatedContainsNestedMap_NestedMap(r randyTheproto3, easy bool) *ContainsNestedMap_NestedMap {
	this := &ContainsNestedMap_NestedMap{}
	if r.Intn(10) != 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 {
	}
	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 {
	}
	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) {
	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))
		}
	}
	return n
}

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

func (m *AllMaps) Size() (n int) {
	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))
		}
	}
	return n
}

func (m *AllMapsOrdered) Size() (n int) {
	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))
		}
	}
	return n
}

func (m *MessageWithMap) Size() (n int) {
	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))
		}
	}
	return n
}

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

func (m *Uint128Pair) Size() (n int) {
	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))
	}
	return n
}

func (m *ContainsNestedMap) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *ContainsNestedMap_NestedMap) Size() (n int) {
	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))
		}
	}
	return n
}

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

func sovTheproto3(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
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]*test.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(fmt.Sprintf("%v", this.Nested), "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", "test.NinOptNative", 1) + `,`,
		`Proto2Value:` + mapStringForProto2Value + `,`,
		`}`,
	}, "")
	return s
}
func (this *Nested) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Nested{`,
		`Bunny:` + fmt.Sprintf("%v", this.Bunny) + `,`,
		`}`,
	}, "")
	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 + `,`,
		`}`,
	}, "")
	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 + `,`,
		`}`,
	}, "")
	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 + `,`,
		`}`,
	}, "")
	return s
}
func (this *FloatingPoint) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FloatingPoint{`,
		`F:` + fmt.Sprintf("%v", this.F) + `,`,
		`}`,
	}, "")
	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) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ContainsNestedMap) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ContainsNestedMap{`,
		`}`,
	}, "")
	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 + `,`,
		`}`,
	}, "")
	return s
}
func (this *NotPacked) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NotPacked{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`}`,
	}, "")
	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 > 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 > 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 > l {
					return io.ErrUnexpectedEOF
				}
				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 > 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
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int64
			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
				}
			}
			if m.Terrain == nil {
				m.Terrain = make(map[int64]*Nested)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 mapmsglen < 0 {
					return ErrInvalidLengthTheproto3
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &Nested{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Terrain[mapkey] = mapvalue
			} else {
				var mapvalue *Nested
				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 > l {
				return io.ErrUnexpectedEOF
			}
			if m.Proto2Field == nil {
				m.Proto2Field = &test.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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int64
			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
				}
			}
			if m.Proto2Value == nil {
				m.Proto2Value = make(map[int64]*test.NinOptEnum)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 mapmsglen < 0 {
					return ErrInvalidLengthTheproto3
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &test.NinOptEnum{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.Proto2Value[mapkey] = mapvalue
			} else {
				var mapvalue *test.NinOptEnum
				m.Proto2Value[mapkey] = mapvalue
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToDoubleMap == nil {
				m.StringToDoubleMap = make(map[string]float64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvaluetemp uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 8
				mapvaluetemp = uint64(dAtA[iNdEx-8])
				mapvaluetemp |= uint64(dAtA[iNdEx-7]) << 8
				mapvaluetemp |= uint64(dAtA[iNdEx-6]) << 16
				mapvaluetemp |= uint64(dAtA[iNdEx-5]) << 24
				mapvaluetemp |= uint64(dAtA[iNdEx-4]) << 32
				mapvaluetemp |= uint64(dAtA[iNdEx-3]) << 40
				mapvaluetemp |= uint64(dAtA[iNdEx-2]) << 48
				mapvaluetemp |= uint64(dAtA[iNdEx-1]) << 56
				mapvalue := math.Float64frombits(mapvaluetemp)
				m.StringToDoubleMap[mapkey] = mapvalue
			} else {
				var mapvalue float64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToFloatMap == nil {
				m.StringToFloatMap = make(map[string]float32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvaluetemp uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 4
				mapvaluetemp = uint32(dAtA[iNdEx-4])
				mapvaluetemp |= uint32(dAtA[iNdEx-3]) << 8
				mapvaluetemp |= uint32(dAtA[iNdEx-2]) << 16
				mapvaluetemp |= uint32(dAtA[iNdEx-1]) << 24
				mapvalue := math.Float32frombits(mapvaluetemp)
				m.StringToFloatMap[mapkey] = mapvalue
			} else {
				var mapvalue float32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			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
				}
			}
			if m.Int32Map == nil {
				m.Int32Map = make(map[int32]int32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int32
				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
					}
				}
				m.Int32Map[mapkey] = mapvalue
			} else {
				var mapvalue int32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int64
			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
				}
			}
			if m.Int64Map == nil {
				m.Int64Map = make(map[int64]int64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int64
				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
					}
				}
				m.Int64Map[mapkey] = mapvalue
			} else {
				var mapvalue int64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint32
			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
				}
			}
			if m.Uint32Map == nil {
				m.Uint32Map = make(map[uint32]uint32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint32
				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
					}
				}
				m.Uint32Map[mapkey] = mapvalue
			} else {
				var mapvalue uint32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint64
			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
				}
			}
			if m.Uint64Map == nil {
				m.Uint64Map = make(map[uint64]uint64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint64
				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
					}
				}
				m.Uint64Map[mapkey] = mapvalue
			} else {
				var mapvalue uint64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.Sint32Map == nil {
				m.Sint32Map = make(map[int32]int32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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)
				m.Sint32Map[mapkey] = mapvalue
			} else {
				var mapvalue int32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.Sint64Map == nil {
				m.Sint64Map = make(map[int64]int64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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)
				m.Sint64Map[mapkey] = mapvalue
			} else {
				var mapvalue int64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			mapkey = uint32(dAtA[iNdEx-4])
			mapkey |= uint32(dAtA[iNdEx-3]) << 8
			mapkey |= uint32(dAtA[iNdEx-2]) << 16
			mapkey |= uint32(dAtA[iNdEx-1]) << 24
			if m.Fixed32Map == nil {
				m.Fixed32Map = make(map[uint32]uint32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 4
				mapvalue = uint32(dAtA[iNdEx-4])
				mapvalue |= uint32(dAtA[iNdEx-3]) << 8
				mapvalue |= uint32(dAtA[iNdEx-2]) << 16
				mapvalue |= uint32(dAtA[iNdEx-1]) << 24
				m.Fixed32Map[mapkey] = mapvalue
			} else {
				var mapvalue uint32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			mapkey = int32(dAtA[iNdEx-4])
			mapkey |= int32(dAtA[iNdEx-3]) << 8
			mapkey |= int32(dAtA[iNdEx-2]) << 16
			mapkey |= int32(dAtA[iNdEx-1]) << 24
			if m.Sfixed32Map == nil {
				m.Sfixed32Map = make(map[int32]int32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 4
				mapvalue = int32(dAtA[iNdEx-4])
				mapvalue |= int32(dAtA[iNdEx-3]) << 8
				mapvalue |= int32(dAtA[iNdEx-2]) << 16
				mapvalue |= int32(dAtA[iNdEx-1]) << 24
				m.Sfixed32Map[mapkey] = mapvalue
			} else {
				var mapvalue int32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 8
			mapkey = uint64(dAtA[iNdEx-8])
			mapkey |= uint64(dAtA[iNdEx-7]) << 8
			mapkey |= uint64(dAtA[iNdEx-6]) << 16
			mapkey |= uint64(dAtA[iNdEx-5]) << 24
			mapkey |= uint64(dAtA[iNdEx-4]) << 32
			mapkey |= uint64(dAtA[iNdEx-3]) << 40
			mapkey |= uint64(dAtA[iNdEx-2]) << 48
			mapkey |= uint64(dAtA[iNdEx-1]) << 56
			if m.Fixed64Map == nil {
				m.Fixed64Map = make(map[uint64]uint64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 8
				mapvalue = uint64(dAtA[iNdEx-8])
				mapvalue |= uint64(dAtA[iNdEx-7]) << 8
				mapvalue |= uint64(dAtA[iNdEx-6]) << 16
				mapvalue |= uint64(dAtA[iNdEx-5]) << 24
				mapvalue |= uint64(dAtA[iNdEx-4]) << 32
				mapvalue |= uint64(dAtA[iNdEx-3]) << 40
				mapvalue |= uint64(dAtA[iNdEx-2]) << 48
				mapvalue |= uint64(dAtA[iNdEx-1]) << 56
				m.Fixed64Map[mapkey] = mapvalue
			} else {
				var mapvalue uint64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 8
			mapkey = int64(dAtA[iNdEx-8])
			mapkey |= int64(dAtA[iNdEx-7]) << 8
			mapkey |= int64(dAtA[iNdEx-6]) << 16
			mapkey |= int64(dAtA[iNdEx-5]) << 24
			mapkey |= int64(dAtA[iNdEx-4]) << 32
			mapkey |= int64(dAtA[iNdEx-3]) << 40
			mapkey |= int64(dAtA[iNdEx-2]) << 48
			mapkey |= int64(dAtA[iNdEx-1]) << 56
			if m.Sfixed64Map == nil {
				m.Sfixed64Map = make(map[int64]int64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 8
				mapvalue = int64(dAtA[iNdEx-8])
				mapvalue |= int64(dAtA[iNdEx-7]) << 8
				mapvalue |= int64(dAtA[iNdEx-6]) << 16
				mapvalue |= int64(dAtA[iNdEx-5]) << 24
				mapvalue |= int64(dAtA[iNdEx-4]) << 32
				mapvalue |= int64(dAtA[iNdEx-3]) << 40
				mapvalue |= int64(dAtA[iNdEx-2]) << 48
				mapvalue |= int64(dAtA[iNdEx-1]) << 56
				m.Sfixed64Map[mapkey] = mapvalue
			} else {
				var mapvalue int64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.BoolMap == nil {
				m.BoolMap = make(map[bool]bool)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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)
				m.BoolMap[mapkey] = mapvalue
			} else {
				var mapvalue bool
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringMap == nil {
				m.StringMap = make(map[string]string)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
				iNdEx = postStringIndexmapvalue
				m.StringMap[mapkey] = mapvalue
			} else {
				var mapvalue string
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToBytesMap == nil {
				m.StringToBytesMap = make(map[string][]byte)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := make([]byte, mapbyteLen)
				copy(mapvalue, dAtA[iNdEx:postbytesIndex])
				iNdEx = postbytesIndex
				m.StringToBytesMap[mapkey] = mapvalue
			} else {
				var mapvalue []byte
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToEnumMap == nil {
				m.StringToEnumMap = make(map[string]MapEnum)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue MapEnum
				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
					}
				}
				m.StringToEnumMap[mapkey] = mapvalue
			} else {
				var mapvalue MapEnum
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToMsgMap == nil {
				m.StringToMsgMap = make(map[string]*FloatingPoint)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 mapmsglen < 0 {
					return ErrInvalidLengthTheproto3
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &FloatingPoint{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.StringToMsgMap[mapkey] = mapvalue
			} else {
				var mapvalue *FloatingPoint
				m.StringToMsgMap[mapkey] = mapvalue
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToDoubleMap == nil {
				m.StringToDoubleMap = make(map[string]float64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvaluetemp uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 8
				mapvaluetemp = uint64(dAtA[iNdEx-8])
				mapvaluetemp |= uint64(dAtA[iNdEx-7]) << 8
				mapvaluetemp |= uint64(dAtA[iNdEx-6]) << 16
				mapvaluetemp |= uint64(dAtA[iNdEx-5]) << 24
				mapvaluetemp |= uint64(dAtA[iNdEx-4]) << 32
				mapvaluetemp |= uint64(dAtA[iNdEx-3]) << 40
				mapvaluetemp |= uint64(dAtA[iNdEx-2]) << 48
				mapvaluetemp |= uint64(dAtA[iNdEx-1]) << 56
				mapvalue := math.Float64frombits(mapvaluetemp)
				m.StringToDoubleMap[mapkey] = mapvalue
			} else {
				var mapvalue float64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToFloatMap == nil {
				m.StringToFloatMap = make(map[string]float32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvaluetemp uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 4
				mapvaluetemp = uint32(dAtA[iNdEx-4])
				mapvaluetemp |= uint32(dAtA[iNdEx-3]) << 8
				mapvaluetemp |= uint32(dAtA[iNdEx-2]) << 16
				mapvaluetemp |= uint32(dAtA[iNdEx-1]) << 24
				mapvalue := math.Float32frombits(mapvaluetemp)
				m.StringToFloatMap[mapkey] = mapvalue
			} else {
				var mapvalue float32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			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
				}
			}
			if m.Int32Map == nil {
				m.Int32Map = make(map[int32]int32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int32
				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
					}
				}
				m.Int32Map[mapkey] = mapvalue
			} else {
				var mapvalue int32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int64
			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
				}
			}
			if m.Int64Map == nil {
				m.Int64Map = make(map[int64]int64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int64
				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
					}
				}
				m.Int64Map[mapkey] = mapvalue
			} else {
				var mapvalue int64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint32
			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
				}
			}
			if m.Uint32Map == nil {
				m.Uint32Map = make(map[uint32]uint32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint32
				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
					}
				}
				m.Uint32Map[mapkey] = mapvalue
			} else {
				var mapvalue uint32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint64
			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
				}
			}
			if m.Uint64Map == nil {
				m.Uint64Map = make(map[uint64]uint64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint64
				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
					}
				}
				m.Uint64Map[mapkey] = mapvalue
			} else {
				var mapvalue uint64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.Sint32Map == nil {
				m.Sint32Map = make(map[int32]int32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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)
				m.Sint32Map[mapkey] = mapvalue
			} else {
				var mapvalue int32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.Sint64Map == nil {
				m.Sint64Map = make(map[int64]int64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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)
				m.Sint64Map[mapkey] = mapvalue
			} else {
				var mapvalue int64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			mapkey = uint32(dAtA[iNdEx-4])
			mapkey |= uint32(dAtA[iNdEx-3]) << 8
			mapkey |= uint32(dAtA[iNdEx-2]) << 16
			mapkey |= uint32(dAtA[iNdEx-1]) << 24
			if m.Fixed32Map == nil {
				m.Fixed32Map = make(map[uint32]uint32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 4
				mapvalue = uint32(dAtA[iNdEx-4])
				mapvalue |= uint32(dAtA[iNdEx-3]) << 8
				mapvalue |= uint32(dAtA[iNdEx-2]) << 16
				mapvalue |= uint32(dAtA[iNdEx-1]) << 24
				m.Fixed32Map[mapkey] = mapvalue
			} else {
				var mapvalue uint32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			mapkey = int32(dAtA[iNdEx-4])
			mapkey |= int32(dAtA[iNdEx-3]) << 8
			mapkey |= int32(dAtA[iNdEx-2]) << 16
			mapkey |= int32(dAtA[iNdEx-1]) << 24
			if m.Sfixed32Map == nil {
				m.Sfixed32Map = make(map[int32]int32)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 4
				mapvalue = int32(dAtA[iNdEx-4])
				mapvalue |= int32(dAtA[iNdEx-3]) << 8
				mapvalue |= int32(dAtA[iNdEx-2]) << 16
				mapvalue |= int32(dAtA[iNdEx-1]) << 24
				m.Sfixed32Map[mapkey] = mapvalue
			} else {
				var mapvalue int32
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 8
			mapkey = uint64(dAtA[iNdEx-8])
			mapkey |= uint64(dAtA[iNdEx-7]) << 8
			mapkey |= uint64(dAtA[iNdEx-6]) << 16
			mapkey |= uint64(dAtA[iNdEx-5]) << 24
			mapkey |= uint64(dAtA[iNdEx-4]) << 32
			mapkey |= uint64(dAtA[iNdEx-3]) << 40
			mapkey |= uint64(dAtA[iNdEx-2]) << 48
			mapkey |= uint64(dAtA[iNdEx-1]) << 56
			if m.Fixed64Map == nil {
				m.Fixed64Map = make(map[uint64]uint64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 8
				mapvalue = uint64(dAtA[iNdEx-8])
				mapvalue |= uint64(dAtA[iNdEx-7]) << 8
				mapvalue |= uint64(dAtA[iNdEx-6]) << 16
				mapvalue |= uint64(dAtA[iNdEx-5]) << 24
				mapvalue |= uint64(dAtA[iNdEx-4]) << 32
				mapvalue |= uint64(dAtA[iNdEx-3]) << 40
				mapvalue |= uint64(dAtA[iNdEx-2]) << 48
				mapvalue |= uint64(dAtA[iNdEx-1]) << 56
				m.Fixed64Map[mapkey] = mapvalue
			} else {
				var mapvalue uint64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 8
			mapkey = int64(dAtA[iNdEx-8])
			mapkey |= int64(dAtA[iNdEx-7]) << 8
			mapkey |= int64(dAtA[iNdEx-6]) << 16
			mapkey |= int64(dAtA[iNdEx-5]) << 24
			mapkey |= int64(dAtA[iNdEx-4]) << 32
			mapkey |= int64(dAtA[iNdEx-3]) << 40
			mapkey |= int64(dAtA[iNdEx-2]) << 48
			mapkey |= int64(dAtA[iNdEx-1]) << 56
			if m.Sfixed64Map == nil {
				m.Sfixed64Map = make(map[int64]int64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue int64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 8
				mapvalue = int64(dAtA[iNdEx-8])
				mapvalue |= int64(dAtA[iNdEx-7]) << 8
				mapvalue |= int64(dAtA[iNdEx-6]) << 16
				mapvalue |= int64(dAtA[iNdEx-5]) << 24
				mapvalue |= int64(dAtA[iNdEx-4]) << 32
				mapvalue |= int64(dAtA[iNdEx-3]) << 40
				mapvalue |= int64(dAtA[iNdEx-2]) << 48
				mapvalue |= int64(dAtA[iNdEx-1]) << 56
				m.Sfixed64Map[mapkey] = mapvalue
			} else {
				var mapvalue int64
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.BoolMap == nil {
				m.BoolMap = make(map[bool]bool)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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)
				m.BoolMap[mapkey] = mapvalue
			} else {
				var mapvalue bool
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringMap == nil {
				m.StringMap = make(map[string]string)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
				iNdEx = postStringIndexmapvalue
				m.StringMap[mapkey] = mapvalue
			} else {
				var mapvalue string
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToBytesMap == nil {
				m.StringToBytesMap = make(map[string][]byte)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := make([]byte, mapbyteLen)
				copy(mapvalue, dAtA[iNdEx:postbytesIndex])
				iNdEx = postbytesIndex
				m.StringToBytesMap[mapkey] = mapvalue
			} else {
				var mapvalue []byte
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToEnumMap == nil {
				m.StringToEnumMap = make(map[string]MapEnum)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvalue MapEnum
				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
					}
				}
				m.StringToEnumMap[mapkey] = mapvalue
			} else {
				var mapvalue MapEnum
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.StringToMsgMap == nil {
				m.StringToMsgMap = make(map[string]*FloatingPoint)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 mapmsglen < 0 {
					return ErrInvalidLengthTheproto3
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &FloatingPoint{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.StringToMsgMap[mapkey] = mapvalue
			} else {
				var mapvalue *FloatingPoint
				m.StringToMsgMap[mapkey] = mapvalue
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			var mapkey int32
			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
				}
			}
			if m.NameMapping == nil {
				m.NameMapping = make(map[int32]string)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue])
				iNdEx = postStringIndexmapvalue
				m.NameMapping[mapkey] = mapvalue
			} else {
				var mapvalue string
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.MsgMapping == nil {
				m.MsgMapping = make(map[int64]*FloatingPoint)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 mapmsglen < 0 {
					return ErrInvalidLengthTheproto3
				}
				if postmsgIndex > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := &FloatingPoint{}
				if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
					return err
				}
				iNdEx = postmsgIndex
				m.MsgMapping[mapkey] = mapvalue
			} else {
				var mapvalue *FloatingPoint
				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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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)
			if m.ByteMapping == nil {
				m.ByteMapping = make(map[bool][]byte)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				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 > l {
					return io.ErrUnexpectedEOF
				}
				mapvalue := make([]byte, mapbyteLen)
				copy(mapvalue, dAtA[iNdEx:postbytesIndex])
				iNdEx = postbytesIndex
				m.ByteMapping[mapkey] = mapvalue
			} else {
				var mapvalue []byte
				m.ByteMapping[mapkey] = mapvalue
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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
			}
			iNdEx += 8
			v = uint64(dAtA[iNdEx-8])
			v |= uint64(dAtA[iNdEx-7]) << 8
			v |= uint64(dAtA[iNdEx-6]) << 16
			v |= uint64(dAtA[iNdEx-5]) << 24
			v |= uint64(dAtA[iNdEx-4]) << 32
			v |= uint64(dAtA[iNdEx-3]) << 40
			v |= uint64(dAtA[iNdEx-2]) << 48
			v |= uint64(dAtA[iNdEx-1]) << 56
			m.F = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > 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 > 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 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			var keykey uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTheproto3
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				keykey |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			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 > l {
				return io.ErrUnexpectedEOF
			}
			mapkey := string(dAtA[iNdEx:postStringIndexmapkey])
			iNdEx = postStringIndexmapkey
			if m.NestedMapField == nil {
				m.NestedMapField = make(map[string]float64)
			}
			if iNdEx < postIndex {
				var valuekey uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTheproto3
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					valuekey |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				var mapvaluetemp uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += 8
				mapvaluetemp = uint64(dAtA[iNdEx-8])
				mapvaluetemp |= uint64(dAtA[iNdEx-7]) << 8
				mapvaluetemp |= uint64(dAtA[iNdEx-6]) << 16
				mapvaluetemp |= uint64(dAtA[iNdEx-5]) << 24
				mapvaluetemp |= uint64(dAtA[iNdEx-4]) << 32
				mapvaluetemp |= uint64(dAtA[iNdEx-3]) << 40
				mapvaluetemp |= uint64(dAtA[iNdEx-2]) << 48
				mapvaluetemp |= uint64(dAtA[iNdEx-1]) << 56
				mapvalue := math.Float64frombits(mapvaluetemp)
				m.NestedMapField[mapkey] = mapvalue
			} else {
				var mapvalue float64
				m.NestedMapField[mapkey] = mapvalue
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTheproto3(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 > l {
					return io.ErrUnexpectedEOF
				}
				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 {
				return ErrInvalidLengthTheproto3
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthTheproto3 = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTheproto3   = fmt.Errorf("proto: integer overflow")
)

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

var fileDescriptorTheproto3 = []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, 0x56, 0x20, 0xf2, 0x54,
	0x3f, 0xc9, 0xc7, 0x0a, 0x91, 0x52, 0xb4, 0x41, 0x2f, 0xf1, 0x55, 0x88, 0x9b, 0xba, 0x4d, 0xf4,
	0xc3, 0x7c, 0xbc, 0x80, 0x4a, 0xe9, 0x95, 0x79, 0x61, 0xf2, 0x3a, 0xfb, 0x43, 0xc3, 0x49, 0xc0,
	0x4b, 0x90, 0xe9, 0xeb, 0xf6, 0xa0, 0x4b, 0xf6, 0x0f, 0xac, 0x81, 0x49, 0xf2, 0x89, 0x02, 0x2a,
	0x45, 0x1a, 0x69, 0x1e, 0xab, 0xd2, 0x10, 0xbe, 0x04, 0x59, 0xd2, 0x1f, 0xe8, 0xfb, 0xf6, 0x81,
	0x45, 0xec, 0x9e, 0x66, 0xe6, 0x93, 0x05, 0x54, 0x4a, 0x36, 0x32, 0x34, 0xd8, 0x74, 0x62, 0xf8,
	0x22, 0xc4, 0xec, 0x03, 0xab, 0xaf, 0xe7, 0x53, 0x05, 0x54, 0x0a, 0x37, 0xf8, 0x00, 0xff, 0x1f,
	0x12, 0x44, 0xef, 0xf7, 0x35, 0xc3, 0xcc, 0x43, 0x21, 0x52, 0x4a, 0xaf, 0x2c, 0x4a, 0x96, 0x61,
	0x87, 0x67, 0xac, 0x9b, 0xa4, 0x7f, 0xd2, 0x18, 0xe5, 0xe3, 0xdb, 0x90, 0x61, 0x79, 0x2b, 0xfb,
	0x47, 0x86, 0xde, 0x3d, 0xcc, 0xa7, 0xd9, 0x9d, 0xe0, 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, 0x8b, 0x8c, 0xd8, 0xf2, 0xb0,
	0x45, 0xbe, 0x02, 0x31, 0x3e, 0x45, 0xd8, 0x6f, 0x8d, 0xf9, 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, 0x76, 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,
	0xcf, 0xa2, 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, 0x77, 0x56, 0x01, 0x1d, 0x60, 0x1a,
	0x00, 0x00,
}
