cmd/protoc-gen-go/testdata/proto2/fields.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: proto2/fields.proto

package proto2

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

type FieldTestMessage_Enum int32

const (
	FieldTestMessage_ZERO FieldTestMessage_Enum = 0
	FieldTestMessage_ONE  FieldTestMessage_Enum = 1
)

var FieldTestMessage_Enum_name = map[int32]string{
	0: "ZERO",
	1: "ONE",
}

var FieldTestMessage_Enum_value = map[string]int32{
	"ZERO": 0,
	"ONE":  1,
}

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

func (x FieldTestMessage_Enum) String() string {
	return proto.EnumName(FieldTestMessage_Enum_name, int32(x))
}

func (x *FieldTestMessage_Enum) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(FieldTestMessage_Enum_value, data, "FieldTestMessage_Enum")
	if err != nil {
		return err
	}
	*x = FieldTestMessage_Enum(value)
	return nil
}

func (FieldTestMessage_Enum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_fd8a9d72b841fd68, []int{0, 0}
}

type FieldTestMessage struct {
	OptionalBool         *bool                                `protobuf:"varint,1,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
	OptionalEnum         *FieldTestMessage_Enum               `protobuf:"varint,2,opt,name=optional_enum,json=optionalEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum" json:"optional_enum,omitempty"`
	OptionalInt32        *int32                               `protobuf:"varint,3,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
	OptionalSint32       *int32                               `protobuf:"zigzag32,4,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
	OptionalUint32       *uint32                              `protobuf:"varint,5,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
	OptionalInt64        *int64                               `protobuf:"varint,6,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
	OptionalSint64       *int64                               `protobuf:"zigzag64,7,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
	OptionalUint64       *uint64                              `protobuf:"varint,8,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
	OptionalSfixed32     *int32                               `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
	OptionalFixed32      *uint32                              `protobuf:"fixed32,10,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
	OptionalFloat        *float32                             `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
	OptionalSfixed64     *int64                               `protobuf:"fixed64,12,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
	OptionalFixed64      *uint64                              `protobuf:"fixed64,13,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
	OptionalDouble       *float64                             `protobuf:"fixed64,14,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
	OptionalString       *string                              `protobuf:"bytes,15,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
	OptionalBytes        []byte                               `protobuf:"bytes,16,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
	Optional_Message     *FieldTestMessage_Message            `protobuf:"bytes,17,opt,name=optional_Message,json=optionalMessage" json:"optional_Message,omitempty"`
	Optionalgroup        *FieldTestMessage_OptionalGroup      `protobuf:"group,18,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
	RequiredBool         *bool                                `protobuf:"varint,101,req,name=required_bool,json=requiredBool" json:"required_bool,omitempty"`
	RequiredEnum         *FieldTestMessage_Enum               `protobuf:"varint,102,req,name=required_enum,json=requiredEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum" json:"required_enum,omitempty"`
	RequiredInt32        *int32                               `protobuf:"varint,103,req,name=required_int32,json=requiredInt32" json:"required_int32,omitempty"`
	RequiredSint32       *int32                               `protobuf:"zigzag32,104,req,name=required_sint32,json=requiredSint32" json:"required_sint32,omitempty"`
	RequiredUint32       *uint32                              `protobuf:"varint,105,req,name=required_uint32,json=requiredUint32" json:"required_uint32,omitempty"`
	RequiredInt64        *int64                               `protobuf:"varint,106,req,name=required_int64,json=requiredInt64" json:"required_int64,omitempty"`
	RequiredSint64       *int64                               `protobuf:"zigzag64,107,req,name=required_sint64,json=requiredSint64" json:"required_sint64,omitempty"`
	RequiredUint64       *uint64                              `protobuf:"varint,108,req,name=required_uint64,json=requiredUint64" json:"required_uint64,omitempty"`
	RequiredSfixed32     *int32                               `protobuf:"fixed32,109,req,name=required_sfixed32,json=requiredSfixed32" json:"required_sfixed32,omitempty"`
	RequiredFixed32      *uint32                              `protobuf:"fixed32,110,req,name=required_fixed32,json=requiredFixed32" json:"required_fixed32,omitempty"`
	RequiredFloat        *float32                             `protobuf:"fixed32,111,req,name=required_float,json=requiredFloat" json:"required_float,omitempty"`
	RequiredSfixed64     *int64                               `protobuf:"fixed64,112,req,name=required_sfixed64,json=requiredSfixed64" json:"required_sfixed64,omitempty"`
	RequiredFixed64      *uint64                              `protobuf:"fixed64,113,req,name=required_fixed64,json=requiredFixed64" json:"required_fixed64,omitempty"`
	RequiredDouble       *float64                             `protobuf:"fixed64,114,req,name=required_double,json=requiredDouble" json:"required_double,omitempty"`
	RequiredString       *string                              `protobuf:"bytes,115,req,name=required_string,json=requiredString" json:"required_string,omitempty"`
	RequiredBytes        []byte                               `protobuf:"bytes,116,req,name=required_bytes,json=requiredBytes" json:"required_bytes,omitempty"`
	Required_Message     *FieldTestMessage_Message            `protobuf:"bytes,117,req,name=required_Message,json=requiredMessage" json:"required_Message,omitempty"`
	Requiredgroup        *FieldTestMessage_RequiredGroup      `protobuf:"group,118,req,name=RequiredGroup,json=requiredgroup" json:"requiredgroup,omitempty"`
	RepeatedBool         []bool                               `protobuf:"varint,201,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
	RepeatedEnum         []FieldTestMessage_Enum              `protobuf:"varint,202,rep,name=repeated_enum,json=repeatedEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum" json:"repeated_enum,omitempty"`
	RepeatedInt32        []int32                              `protobuf:"varint,203,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
	RepeatedSint32       []int32                              `protobuf:"zigzag32,204,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
	RepeatedUint32       []uint32                             `protobuf:"varint,205,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
	RepeatedInt64        []int64                              `protobuf:"varint,206,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
	RepeatedSint64       []int64                              `protobuf:"zigzag64,207,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
	RepeatedUint64       []uint64                             `protobuf:"varint,208,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
	RepeatedSfixed32     []int32                              `protobuf:"fixed32,209,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
	RepeatedFixed32      []uint32                             `protobuf:"fixed32,210,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
	RepeatedFloat        []float32                            `protobuf:"fixed32,211,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
	RepeatedSfixed64     []int64                              `protobuf:"fixed64,212,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
	RepeatedFixed64      []uint64                             `protobuf:"fixed64,213,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
	RepeatedDouble       []float64                            `protobuf:"fixed64,214,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
	RepeatedString       []string                             `protobuf:"bytes,215,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
	RepeatedBytes        [][]byte                             `protobuf:"bytes,216,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty"`
	Repeated_Message     []*FieldTestMessage_Message          `protobuf:"bytes,217,rep,name=repeated_Message,json=repeatedMessage" json:"repeated_Message,omitempty"`
	Repeatedgroup        []*FieldTestMessage_RepeatedGroup    `protobuf:"group,218,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
	DefaultBool          *bool                                `protobuf:"varint,301,opt,name=default_bool,json=defaultBool,def=1" json:"default_bool,omitempty"`
	DefaultEnum          *FieldTestMessage_Enum               `protobuf:"varint,302,opt,name=default_enum,json=defaultEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum,def=1" json:"default_enum,omitempty"`
	DefaultInt32         *int32                               `protobuf:"varint,303,opt,name=default_int32,json=defaultInt32,def=1" json:"default_int32,omitempty"`
	DefaultSint32        *int32                               `protobuf:"zigzag32,304,opt,name=default_sint32,json=defaultSint32,def=1" json:"default_sint32,omitempty"`
	DefaultUint32        *uint32                              `protobuf:"varint,305,opt,name=default_uint32,json=defaultUint32,def=1" json:"default_uint32,omitempty"`
	DefaultInt64         *int64                               `protobuf:"varint,306,opt,name=default_int64,json=defaultInt64,def=1" json:"default_int64,omitempty"`
	DefaultSint64        *int64                               `protobuf:"zigzag64,307,opt,name=default_sint64,json=defaultSint64,def=1" json:"default_sint64,omitempty"`
	DefaultUint64        *uint64                              `protobuf:"varint,308,opt,name=default_uint64,json=defaultUint64,def=1" json:"default_uint64,omitempty"`
	DefaultSfixed32      *int32                               `protobuf:"fixed32,309,opt,name=default_sfixed32,json=defaultSfixed32,def=1" json:"default_sfixed32,omitempty"`
	DefaultFixed32       *uint32                              `protobuf:"fixed32,310,opt,name=default_fixed32,json=defaultFixed32,def=1" json:"default_fixed32,omitempty"`
	DefaultFloat         *float32                             `protobuf:"fixed32,311,opt,name=default_float,json=defaultFloat,def=1.5" json:"default_float,omitempty"`
	DefaultSfixed64      *int64                               `protobuf:"fixed64,312,opt,name=default_sfixed64,json=defaultSfixed64,def=1" json:"default_sfixed64,omitempty"`
	DefaultFixed64       *uint64                              `protobuf:"fixed64,313,opt,name=default_fixed64,json=defaultFixed64,def=1" json:"default_fixed64,omitempty"`
	DefaultDouble        *float64                             `protobuf:"fixed64,314,opt,name=default_double,json=defaultDouble,def=1.5" json:"default_double,omitempty"`
	DefaultString        *string                              `protobuf:"bytes,315,opt,name=default_string,json=defaultString,def=x,y" json:"default_string,omitempty"`
	DefaultBytes         []byte                               `protobuf:"bytes,316,opt,name=default_bytes,json=defaultBytes,def=x,y" json:"default_bytes,omitempty"`
	DefaultFloatNeginf   *float32                             `protobuf:"fixed32,400,opt,name=default_float_neginf,json=defaultFloatNeginf,def=-inf" json:"default_float_neginf,omitempty"`
	DefaultFloatPosinf   *float32                             `protobuf:"fixed32,401,opt,name=default_float_posinf,json=defaultFloatPosinf,def=inf" json:"default_float_posinf,omitempty"`
	DefaultFloatNan      *float32                             `protobuf:"fixed32,402,opt,name=default_float_nan,json=defaultFloatNan,def=nan" json:"default_float_nan,omitempty"`
	DefaultDoubleNeginf  *float64                             `protobuf:"fixed64,403,opt,name=default_double_neginf,json=defaultDoubleNeginf,def=-inf" json:"default_double_neginf,omitempty"`
	DefaultDoublePosinf  *float64                             `protobuf:"fixed64,404,opt,name=default_double_posinf,json=defaultDoublePosinf,def=inf" json:"default_double_posinf,omitempty"`
	DefaultDoubleNan     *float64                             `protobuf:"fixed64,405,opt,name=default_double_nan,json=defaultDoubleNan,def=nan" json:"default_double_nan,omitempty"`
	MapInt32Int64        map[int32]int64                      `protobuf:"bytes,500,rep,name=map_int32_int64,json=mapInt32Int64" json:"map_int32_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MapStringMessage     map[string]*FieldTestMessage_Message `protobuf:"bytes,501,rep,name=map_string_message,json=mapStringMessage" json:"map_string_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	MapFixed64Enum       map[uint64]FieldTestMessage_Enum     `protobuf:"bytes,502,rep,name=map_fixed64_enum,json=mapFixed64Enum" json:"map_fixed64_enum,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=goproto.protoc.proto2.FieldTestMessage_Enum"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

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

var xxx_messageInfo_FieldTestMessage proto.InternalMessageInfo

const Default_FieldTestMessage_DefaultBool bool = true
const Default_FieldTestMessage_DefaultEnum FieldTestMessage_Enum = FieldTestMessage_ONE
const Default_FieldTestMessage_DefaultInt32 int32 = 1
const Default_FieldTestMessage_DefaultSint32 int32 = 1
const Default_FieldTestMessage_DefaultUint32 uint32 = 1
const Default_FieldTestMessage_DefaultInt64 int64 = 1
const Default_FieldTestMessage_DefaultSint64 int64 = 1
const Default_FieldTestMessage_DefaultUint64 uint64 = 1
const Default_FieldTestMessage_DefaultSfixed32 int32 = 1
const Default_FieldTestMessage_DefaultFixed32 uint32 = 1
const Default_FieldTestMessage_DefaultFloat float32 = 1.5
const Default_FieldTestMessage_DefaultSfixed64 int64 = 1
const Default_FieldTestMessage_DefaultFixed64 uint64 = 1
const Default_FieldTestMessage_DefaultDouble float64 = 1.5
const Default_FieldTestMessage_DefaultString string = "x,y"

var Default_FieldTestMessage_DefaultBytes []byte = []byte("x,y")
var Default_FieldTestMessage_DefaultFloatNeginf float32 = float32(math.Inf(-1))
var Default_FieldTestMessage_DefaultFloatPosinf float32 = float32(math.Inf(1))
var Default_FieldTestMessage_DefaultFloatNan float32 = float32(math.NaN())
var Default_FieldTestMessage_DefaultDoubleNeginf float64 = math.Inf(-1)
var Default_FieldTestMessage_DefaultDoublePosinf float64 = math.Inf(1)
var Default_FieldTestMessage_DefaultDoubleNan float64 = math.NaN()

func (m *FieldTestMessage) GetOptionalBool() bool {
	if m != nil && m.OptionalBool != nil {
		return *m.OptionalBool
	}
	return false
}

func (m *FieldTestMessage) GetOptionalEnum() FieldTestMessage_Enum {
	if m != nil && m.OptionalEnum != nil {
		return *m.OptionalEnum
	}
	return FieldTestMessage_ZERO
}

func (m *FieldTestMessage) GetOptionalInt32() int32 {
	if m != nil && m.OptionalInt32 != nil {
		return *m.OptionalInt32
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalSint32() int32 {
	if m != nil && m.OptionalSint32 != nil {
		return *m.OptionalSint32
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalUint32() uint32 {
	if m != nil && m.OptionalUint32 != nil {
		return *m.OptionalUint32
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalInt64() int64 {
	if m != nil && m.OptionalInt64 != nil {
		return *m.OptionalInt64
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalSint64() int64 {
	if m != nil && m.OptionalSint64 != nil {
		return *m.OptionalSint64
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalUint64() uint64 {
	if m != nil && m.OptionalUint64 != nil {
		return *m.OptionalUint64
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalSfixed32() int32 {
	if m != nil && m.OptionalSfixed32 != nil {
		return *m.OptionalSfixed32
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalFixed32() uint32 {
	if m != nil && m.OptionalFixed32 != nil {
		return *m.OptionalFixed32
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalFloat() float32 {
	if m != nil && m.OptionalFloat != nil {
		return *m.OptionalFloat
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalSfixed64() int64 {
	if m != nil && m.OptionalSfixed64 != nil {
		return *m.OptionalSfixed64
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalFixed64() uint64 {
	if m != nil && m.OptionalFixed64 != nil {
		return *m.OptionalFixed64
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalDouble() float64 {
	if m != nil && m.OptionalDouble != nil {
		return *m.OptionalDouble
	}
	return 0
}

func (m *FieldTestMessage) GetOptionalString() string {
	if m != nil && m.OptionalString != nil {
		return *m.OptionalString
	}
	return ""
}

func (m *FieldTestMessage) GetOptionalBytes() []byte {
	if m != nil {
		return m.OptionalBytes
	}
	return nil
}

func (m *FieldTestMessage) GetOptional_Message() *FieldTestMessage_Message {
	if m != nil {
		return m.Optional_Message
	}
	return nil
}

func (m *FieldTestMessage) GetOptionalgroup() *FieldTestMessage_OptionalGroup {
	if m != nil {
		return m.Optionalgroup
	}
	return nil
}

func (m *FieldTestMessage) GetRequiredBool() bool {
	if m != nil && m.RequiredBool != nil {
		return *m.RequiredBool
	}
	return false
}

func (m *FieldTestMessage) GetRequiredEnum() FieldTestMessage_Enum {
	if m != nil && m.RequiredEnum != nil {
		return *m.RequiredEnum
	}
	return FieldTestMessage_ZERO
}

func (m *FieldTestMessage) GetRequiredInt32() int32 {
	if m != nil && m.RequiredInt32 != nil {
		return *m.RequiredInt32
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredSint32() int32 {
	if m != nil && m.RequiredSint32 != nil {
		return *m.RequiredSint32
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredUint32() uint32 {
	if m != nil && m.RequiredUint32 != nil {
		return *m.RequiredUint32
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredInt64() int64 {
	if m != nil && m.RequiredInt64 != nil {
		return *m.RequiredInt64
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredSint64() int64 {
	if m != nil && m.RequiredSint64 != nil {
		return *m.RequiredSint64
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredUint64() uint64 {
	if m != nil && m.RequiredUint64 != nil {
		return *m.RequiredUint64
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredSfixed32() int32 {
	if m != nil && m.RequiredSfixed32 != nil {
		return *m.RequiredSfixed32
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredFixed32() uint32 {
	if m != nil && m.RequiredFixed32 != nil {
		return *m.RequiredFixed32
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredFloat() float32 {
	if m != nil && m.RequiredFloat != nil {
		return *m.RequiredFloat
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredSfixed64() int64 {
	if m != nil && m.RequiredSfixed64 != nil {
		return *m.RequiredSfixed64
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredFixed64() uint64 {
	if m != nil && m.RequiredFixed64 != nil {
		return *m.RequiredFixed64
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredDouble() float64 {
	if m != nil && m.RequiredDouble != nil {
		return *m.RequiredDouble
	}
	return 0
}

func (m *FieldTestMessage) GetRequiredString() string {
	if m != nil && m.RequiredString != nil {
		return *m.RequiredString
	}
	return ""
}

func (m *FieldTestMessage) GetRequiredBytes() []byte {
	if m != nil {
		return m.RequiredBytes
	}
	return nil
}

func (m *FieldTestMessage) GetRequired_Message() *FieldTestMessage_Message {
	if m != nil {
		return m.Required_Message
	}
	return nil
}

func (m *FieldTestMessage) GetRequiredgroup() *FieldTestMessage_RequiredGroup {
	if m != nil {
		return m.Requiredgroup
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedBool() []bool {
	if m != nil {
		return m.RepeatedBool
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedEnum() []FieldTestMessage_Enum {
	if m != nil {
		return m.RepeatedEnum
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedInt32() []int32 {
	if m != nil {
		return m.RepeatedInt32
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedSint32() []int32 {
	if m != nil {
		return m.RepeatedSint32
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedUint32() []uint32 {
	if m != nil {
		return m.RepeatedUint32
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedInt64() []int64 {
	if m != nil {
		return m.RepeatedInt64
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedSint64() []int64 {
	if m != nil {
		return m.RepeatedSint64
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedUint64() []uint64 {
	if m != nil {
		return m.RepeatedUint64
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedSfixed32() []int32 {
	if m != nil {
		return m.RepeatedSfixed32
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedFixed32() []uint32 {
	if m != nil {
		return m.RepeatedFixed32
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedFloat() []float32 {
	if m != nil {
		return m.RepeatedFloat
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedSfixed64() []int64 {
	if m != nil {
		return m.RepeatedSfixed64
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedFixed64() []uint64 {
	if m != nil {
		return m.RepeatedFixed64
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedDouble() []float64 {
	if m != nil {
		return m.RepeatedDouble
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedString() []string {
	if m != nil {
		return m.RepeatedString
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedBytes() [][]byte {
	if m != nil {
		return m.RepeatedBytes
	}
	return nil
}

func (m *FieldTestMessage) GetRepeated_Message() []*FieldTestMessage_Message {
	if m != nil {
		return m.Repeated_Message
	}
	return nil
}

func (m *FieldTestMessage) GetRepeatedgroup() []*FieldTestMessage_RepeatedGroup {
	if m != nil {
		return m.Repeatedgroup
	}
	return nil
}

func (m *FieldTestMessage) GetDefaultBool() bool {
	if m != nil && m.DefaultBool != nil {
		return *m.DefaultBool
	}
	return Default_FieldTestMessage_DefaultBool
}

func (m *FieldTestMessage) GetDefaultEnum() FieldTestMessage_Enum {
	if m != nil && m.DefaultEnum != nil {
		return *m.DefaultEnum
	}
	return Default_FieldTestMessage_DefaultEnum
}

func (m *FieldTestMessage) GetDefaultInt32() int32 {
	if m != nil && m.DefaultInt32 != nil {
		return *m.DefaultInt32
	}
	return Default_FieldTestMessage_DefaultInt32
}

func (m *FieldTestMessage) GetDefaultSint32() int32 {
	if m != nil && m.DefaultSint32 != nil {
		return *m.DefaultSint32
	}
	return Default_FieldTestMessage_DefaultSint32
}

func (m *FieldTestMessage) GetDefaultUint32() uint32 {
	if m != nil && m.DefaultUint32 != nil {
		return *m.DefaultUint32
	}
	return Default_FieldTestMessage_DefaultUint32
}

func (m *FieldTestMessage) GetDefaultInt64() int64 {
	if m != nil && m.DefaultInt64 != nil {
		return *m.DefaultInt64
	}
	return Default_FieldTestMessage_DefaultInt64
}

func (m *FieldTestMessage) GetDefaultSint64() int64 {
	if m != nil && m.DefaultSint64 != nil {
		return *m.DefaultSint64
	}
	return Default_FieldTestMessage_DefaultSint64
}

func (m *FieldTestMessage) GetDefaultUint64() uint64 {
	if m != nil && m.DefaultUint64 != nil {
		return *m.DefaultUint64
	}
	return Default_FieldTestMessage_DefaultUint64
}

func (m *FieldTestMessage) GetDefaultSfixed32() int32 {
	if m != nil && m.DefaultSfixed32 != nil {
		return *m.DefaultSfixed32
	}
	return Default_FieldTestMessage_DefaultSfixed32
}

func (m *FieldTestMessage) GetDefaultFixed32() uint32 {
	if m != nil && m.DefaultFixed32 != nil {
		return *m.DefaultFixed32
	}
	return Default_FieldTestMessage_DefaultFixed32
}

func (m *FieldTestMessage) GetDefaultFloat() float32 {
	if m != nil && m.DefaultFloat != nil {
		return *m.DefaultFloat
	}
	return Default_FieldTestMessage_DefaultFloat
}

func (m *FieldTestMessage) GetDefaultSfixed64() int64 {
	if m != nil && m.DefaultSfixed64 != nil {
		return *m.DefaultSfixed64
	}
	return Default_FieldTestMessage_DefaultSfixed64
}

func (m *FieldTestMessage) GetDefaultFixed64() uint64 {
	if m != nil && m.DefaultFixed64 != nil {
		return *m.DefaultFixed64
	}
	return Default_FieldTestMessage_DefaultFixed64
}

func (m *FieldTestMessage) GetDefaultDouble() float64 {
	if m != nil && m.DefaultDouble != nil {
		return *m.DefaultDouble
	}
	return Default_FieldTestMessage_DefaultDouble
}

func (m *FieldTestMessage) GetDefaultString() string {
	if m != nil && m.DefaultString != nil {
		return *m.DefaultString
	}
	return Default_FieldTestMessage_DefaultString
}

func (m *FieldTestMessage) GetDefaultBytes() []byte {
	if m != nil && m.DefaultBytes != nil {
		return m.DefaultBytes
	}
	return append([]byte(nil), Default_FieldTestMessage_DefaultBytes...)
}

func (m *FieldTestMessage) GetDefaultFloatNeginf() float32 {
	if m != nil && m.DefaultFloatNeginf != nil {
		return *m.DefaultFloatNeginf
	}
	return Default_FieldTestMessage_DefaultFloatNeginf
}

func (m *FieldTestMessage) GetDefaultFloatPosinf() float32 {
	if m != nil && m.DefaultFloatPosinf != nil {
		return *m.DefaultFloatPosinf
	}
	return Default_FieldTestMessage_DefaultFloatPosinf
}

func (m *FieldTestMessage) GetDefaultFloatNan() float32 {
	if m != nil && m.DefaultFloatNan != nil {
		return *m.DefaultFloatNan
	}
	return Default_FieldTestMessage_DefaultFloatNan
}

func (m *FieldTestMessage) GetDefaultDoubleNeginf() float64 {
	if m != nil && m.DefaultDoubleNeginf != nil {
		return *m.DefaultDoubleNeginf
	}
	return Default_FieldTestMessage_DefaultDoubleNeginf
}

func (m *FieldTestMessage) GetDefaultDoublePosinf() float64 {
	if m != nil && m.DefaultDoublePosinf != nil {
		return *m.DefaultDoublePosinf
	}
	return Default_FieldTestMessage_DefaultDoublePosinf
}

func (m *FieldTestMessage) GetDefaultDoubleNan() float64 {
	if m != nil && m.DefaultDoubleNan != nil {
		return *m.DefaultDoubleNan
	}
	return Default_FieldTestMessage_DefaultDoubleNan
}

func (m *FieldTestMessage) GetMapInt32Int64() map[int32]int64 {
	if m != nil {
		return m.MapInt32Int64
	}
	return nil
}

func (m *FieldTestMessage) GetMapStringMessage() map[string]*FieldTestMessage_Message {
	if m != nil {
		return m.MapStringMessage
	}
	return nil
}

func (m *FieldTestMessage) GetMapFixed64Enum() map[uint64]FieldTestMessage_Enum {
	if m != nil {
		return m.MapFixed64Enum
	}
	return nil
}

type FieldTestMessage_OptionalGroup struct {
	OptionalGroup        *string  `protobuf:"bytes,19,opt,name=optional_group,json=optionalGroup" json:"optional_group,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FieldTestMessage_OptionalGroup proto.InternalMessageInfo

func (m *FieldTestMessage_OptionalGroup) GetOptionalGroup() string {
	if m != nil && m.OptionalGroup != nil {
		return *m.OptionalGroup
	}
	return ""
}

type FieldTestMessage_RequiredGroup struct {
	RequiredGroup        *string  `protobuf:"bytes,119,req,name=required_group,json=requiredGroup" json:"required_group,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FieldTestMessage_RequiredGroup proto.InternalMessageInfo

func (m *FieldTestMessage_RequiredGroup) GetRequiredGroup() string {
	if m != nil && m.RequiredGroup != nil {
		return *m.RequiredGroup
	}
	return ""
}

type FieldTestMessage_RepeatedGroup struct {
	RepeatedGroup        []string `protobuf:"bytes,219,rep,name=repeated_group,json=repeatedGroup" json:"repeated_group,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_FieldTestMessage_RepeatedGroup proto.InternalMessageInfo

func (m *FieldTestMessage_RepeatedGroup) GetRepeatedGroup() []string {
	if m != nil {
		return m.RepeatedGroup
	}
	return nil
}

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

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

var xxx_messageInfo_FieldTestMessage_Message proto.InternalMessageInfo

func init() {
	proto.RegisterType((*FieldTestMessage)(nil), "goproto.protoc.proto2.FieldTestMessage")
	proto.RegisterMapType((map[uint64]FieldTestMessage_Enum)(nil), "goproto.protoc.proto2.FieldTestMessage.MapFixed64EnumEntry")
	proto.RegisterMapType((map[int32]int64)(nil), "goproto.protoc.proto2.FieldTestMessage.MapInt32Int64Entry")
	proto.RegisterMapType((map[string]*FieldTestMessage_Message)(nil), "goproto.protoc.proto2.FieldTestMessage.MapStringMessageEntry")
	proto.RegisterType((*FieldTestMessage_OptionalGroup)(nil), "goproto.protoc.proto2.FieldTestMessage.OptionalGroup")
	proto.RegisterType((*FieldTestMessage_RequiredGroup)(nil), "goproto.protoc.proto2.FieldTestMessage.RequiredGroup")
	proto.RegisterType((*FieldTestMessage_RepeatedGroup)(nil), "goproto.protoc.proto2.FieldTestMessage.RepeatedGroup")
	proto.RegisterType((*FieldTestMessage_Message)(nil), "goproto.protoc.proto2.FieldTestMessage.Message")
	proto.RegisterEnum("goproto.protoc.proto2.FieldTestMessage_Enum", FieldTestMessage_Enum_name, FieldTestMessage_Enum_value)
}

func init() { proto.RegisterFile("proto2/fields.proto", fileDescriptor_fd8a9d72b841fd68) }

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