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

package theproto3

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

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

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

type MapEnum int32

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

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

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

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

type Message_Humour int32

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

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

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

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

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

func (m *Message) Reset()      { *m = Message{} }
func (*Message) ProtoMessage() {}
func (*Message) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{0}
}
func (m *Message) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Message.Unmarshal(m, b)
}
func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
}
func (m *Message) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Message.Merge(m, src)
}
func (m *Message) XXX_Size() int {
	return xxx_messageInfo_Message.Size(m)
}
func (m *Message) XXX_DiscardUnknown() {
	xxx_messageInfo_Message.DiscardUnknown(m)
}

var xxx_messageInfo_Message proto.InternalMessageInfo

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

func (m *Nested) Reset()      { *m = Nested{} }
func (*Nested) ProtoMessage() {}
func (*Nested) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{1}
}
func (m *Nested) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Nested.Unmarshal(m, b)
}
func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
}
func (m *Nested) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Nested.Merge(m, src)
}
func (m *Nested) XXX_Size() int {
	return xxx_messageInfo_Nested.Size(m)
}
func (m *Nested) XXX_DiscardUnknown() {
	xxx_messageInfo_Nested.DiscardUnknown(m)
}

var xxx_messageInfo_Nested proto.InternalMessageInfo

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

func (m *AllMaps) Reset()      { *m = AllMaps{} }
func (*AllMaps) ProtoMessage() {}
func (*AllMaps) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{2}
}
func (m *AllMaps) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AllMaps.Unmarshal(m, b)
}
func (m *AllMaps) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AllMaps.Marshal(b, m, deterministic)
}
func (m *AllMaps) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AllMaps.Merge(m, src)
}
func (m *AllMaps) XXX_Size() int {
	return xxx_messageInfo_AllMaps.Size(m)
}
func (m *AllMaps) XXX_DiscardUnknown() {
	xxx_messageInfo_AllMaps.DiscardUnknown(m)
}

var xxx_messageInfo_AllMaps proto.InternalMessageInfo

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

func (m *AllMapsOrdered) Reset()      { *m = AllMapsOrdered{} }
func (*AllMapsOrdered) ProtoMessage() {}
func (*AllMapsOrdered) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{3}
}
func (m *AllMapsOrdered) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AllMapsOrdered.Unmarshal(m, b)
}
func (m *AllMapsOrdered) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AllMapsOrdered.Marshal(b, m, deterministic)
}
func (m *AllMapsOrdered) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AllMapsOrdered.Merge(m, src)
}
func (m *AllMapsOrdered) XXX_Size() int {
	return xxx_messageInfo_AllMapsOrdered.Size(m)
}
func (m *AllMapsOrdered) XXX_DiscardUnknown() {
	xxx_messageInfo_AllMapsOrdered.DiscardUnknown(m)
}

var xxx_messageInfo_AllMapsOrdered proto.InternalMessageInfo

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

func (m *MessageWithMap) Reset()      { *m = MessageWithMap{} }
func (*MessageWithMap) ProtoMessage() {}
func (*MessageWithMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{4}
}
func (m *MessageWithMap) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MessageWithMap.Unmarshal(m, b)
}
func (m *MessageWithMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MessageWithMap.Marshal(b, m, deterministic)
}
func (m *MessageWithMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageWithMap.Merge(m, src)
}
func (m *MessageWithMap) XXX_Size() int {
	return xxx_messageInfo_MessageWithMap.Size(m)
}
func (m *MessageWithMap) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageWithMap.DiscardUnknown(m)
}

var xxx_messageInfo_MessageWithMap proto.InternalMessageInfo

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

func (m *FloatingPoint) Reset()      { *m = FloatingPoint{} }
func (*FloatingPoint) ProtoMessage() {}
func (*FloatingPoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{5}
}
func (m *FloatingPoint) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FloatingPoint.Unmarshal(m, b)
}
func (m *FloatingPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FloatingPoint.Marshal(b, m, deterministic)
}
func (m *FloatingPoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FloatingPoint.Merge(m, src)
}
func (m *FloatingPoint) XXX_Size() int {
	return xxx_messageInfo_FloatingPoint.Size(m)
}
func (m *FloatingPoint) XXX_DiscardUnknown() {
	xxx_messageInfo_FloatingPoint.DiscardUnknown(m)
}

var xxx_messageInfo_FloatingPoint proto.InternalMessageInfo

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

func (m *Uint128Pair) Reset()      { *m = Uint128Pair{} }
func (*Uint128Pair) ProtoMessage() {}
func (*Uint128Pair) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{6}
}
func (m *Uint128Pair) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Uint128Pair.Unmarshal(m, b)
}
func (m *Uint128Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Uint128Pair.Marshal(b, m, deterministic)
}
func (m *Uint128Pair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uint128Pair.Merge(m, src)
}
func (m *Uint128Pair) XXX_Size() int {
	return xxx_messageInfo_Uint128Pair.Size(m)
}
func (m *Uint128Pair) XXX_DiscardUnknown() {
	xxx_messageInfo_Uint128Pair.DiscardUnknown(m)
}

var xxx_messageInfo_Uint128Pair proto.InternalMessageInfo

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

func (m *ContainsNestedMap) Reset()      { *m = ContainsNestedMap{} }
func (*ContainsNestedMap) ProtoMessage() {}
func (*ContainsNestedMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{7}
}
func (m *ContainsNestedMap) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainsNestedMap.Unmarshal(m, b)
}
func (m *ContainsNestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainsNestedMap.Marshal(b, m, deterministic)
}
func (m *ContainsNestedMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainsNestedMap.Merge(m, src)
}
func (m *ContainsNestedMap) XXX_Size() int {
	return xxx_messageInfo_ContainsNestedMap.Size(m)
}
func (m *ContainsNestedMap) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainsNestedMap.DiscardUnknown(m)
}

var xxx_messageInfo_ContainsNestedMap proto.InternalMessageInfo

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

func (m *ContainsNestedMap_NestedMap) Reset()      { *m = ContainsNestedMap_NestedMap{} }
func (*ContainsNestedMap_NestedMap) ProtoMessage() {}
func (*ContainsNestedMap_NestedMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{7, 0}
}
func (m *ContainsNestedMap_NestedMap) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ContainsNestedMap_NestedMap.Unmarshal(m, b)
}
func (m *ContainsNestedMap_NestedMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ContainsNestedMap_NestedMap.Marshal(b, m, deterministic)
}
func (m *ContainsNestedMap_NestedMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ContainsNestedMap_NestedMap.Merge(m, src)
}
func (m *ContainsNestedMap_NestedMap) XXX_Size() int {
	return xxx_messageInfo_ContainsNestedMap_NestedMap.Size(m)
}
func (m *ContainsNestedMap_NestedMap) XXX_DiscardUnknown() {
	xxx_messageInfo_ContainsNestedMap_NestedMap.DiscardUnknown(m)
}

var xxx_messageInfo_ContainsNestedMap_NestedMap proto.InternalMessageInfo

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

func (m *NotPacked) Reset()      { *m = NotPacked{} }
func (*NotPacked) ProtoMessage() {}
func (*NotPacked) Descriptor() ([]byte, []int) {
	return fileDescriptor_15030c5e29146445, []int{8}
}
func (m *NotPacked) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NotPacked.Unmarshal(m, b)
}
func (m *NotPacked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NotPacked.Marshal(b, m, deterministic)
}
func (m *NotPacked) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NotPacked.Merge(m, src)
}
func (m *NotPacked) XXX_Size() int {
	return xxx_messageInfo_NotPacked.Size(m)
}
func (m *NotPacked) XXX_DiscardUnknown() {
	xxx_messageInfo_NotPacked.DiscardUnknown(m)
}

var xxx_messageInfo_NotPacked proto.InternalMessageInfo

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

func init() { proto.RegisterFile("combos/neither/theproto3.proto", fileDescriptor_15030c5e29146445) }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type ContainsNestedMapFace interface {
	Proto() github_com_gogo_protobuf_proto.Message
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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