golang__protobuf/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"`
	// Types that are valid to be assigned to OneofField:
	//	*FieldTestMessage_OneofBool
	//	*FieldTestMessage_OneofEnum
	//	*FieldTestMessage_OneofInt32
	//	*FieldTestMessage_OneofSint32
	//	*FieldTestMessage_OneofUint32
	//	*FieldTestMessage_OneofInt64
	//	*FieldTestMessage_OneofSint64
	//	*FieldTestMessage_OneofUint64
	//	*FieldTestMessage_OneofSfixed32
	//	*FieldTestMessage_OneofFixed32
	//	*FieldTestMessage_OneofFloat
	//	*FieldTestMessage_OneofSfixed64
	//	*FieldTestMessage_OneofFixed64
	//	*FieldTestMessage_OneofDouble
	//	*FieldTestMessage_OneofString
	//	*FieldTestMessage_OneofBytes
	//	*FieldTestMessage_Oneof_Message
	//	*FieldTestMessage_Oneofgroup
	OneofField isFieldTestMessage_OneofField `protobuf_oneof:"oneof_field"`
	// Types that are valid to be assigned to OneofTwo:
	//	*FieldTestMessage_OneofTwo_1
	//	*FieldTestMessage_OneofTwo_2
	OneofTwo             isFieldTestMessage_OneofTwo `protobuf_oneof:"oneof_two"`
	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 isFieldTestMessage_OneofField interface {
	isFieldTestMessage_OneofField()
}

type FieldTestMessage_OneofBool struct {
	OneofBool bool `protobuf:"varint,601,opt,name=oneof_bool,json=oneofBool,oneof"`
}

type FieldTestMessage_OneofEnum struct {
	OneofEnum FieldTestMessage_Enum `protobuf:"varint,602,opt,name=oneof_enum,json=oneofEnum,enum=goproto.protoc.proto2.FieldTestMessage_Enum,oneof"`
}

type FieldTestMessage_OneofInt32 struct {
	OneofInt32 int32 `protobuf:"varint,603,opt,name=oneof_int32,json=oneofInt32,oneof"`
}

type FieldTestMessage_OneofSint32 struct {
	OneofSint32 int32 `protobuf:"zigzag32,604,opt,name=oneof_sint32,json=oneofSint32,oneof"`
}

type FieldTestMessage_OneofUint32 struct {
	OneofUint32 uint32 `protobuf:"varint,605,opt,name=oneof_uint32,json=oneofUint32,oneof"`
}

type FieldTestMessage_OneofInt64 struct {
	OneofInt64 int64 `protobuf:"varint,606,opt,name=oneof_int64,json=oneofInt64,oneof"`
}

type FieldTestMessage_OneofSint64 struct {
	OneofSint64 int64 `protobuf:"zigzag64,607,opt,name=oneof_sint64,json=oneofSint64,oneof"`
}

type FieldTestMessage_OneofUint64 struct {
	OneofUint64 uint64 `protobuf:"varint,608,opt,name=oneof_uint64,json=oneofUint64,oneof"`
}

type FieldTestMessage_OneofSfixed32 struct {
	OneofSfixed32 int32 `protobuf:"fixed32,609,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
}

type FieldTestMessage_OneofFixed32 struct {
	OneofFixed32 uint32 `protobuf:"fixed32,610,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
}

type FieldTestMessage_OneofFloat struct {
	OneofFloat float32 `protobuf:"fixed32,611,opt,name=oneof_float,json=oneofFloat,oneof"`
}

type FieldTestMessage_OneofSfixed64 struct {
	OneofSfixed64 int64 `protobuf:"fixed64,612,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
}

type FieldTestMessage_OneofFixed64 struct {
	OneofFixed64 uint64 `protobuf:"fixed64,613,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
}

type FieldTestMessage_OneofDouble struct {
	OneofDouble float64 `protobuf:"fixed64,614,opt,name=oneof_double,json=oneofDouble,oneof"`
}

type FieldTestMessage_OneofString struct {
	OneofString string `protobuf:"bytes,615,opt,name=oneof_string,json=oneofString,oneof"`
}

type FieldTestMessage_OneofBytes struct {
	OneofBytes []byte `protobuf:"bytes,616,opt,name=oneof_bytes,json=oneofBytes,oneof"`
}

type FieldTestMessage_Oneof_Message struct {
	Oneof_Message *FieldTestMessage_Message `protobuf:"bytes,617,opt,name=oneof_Message,json=oneofMessage,oneof"`
}

type FieldTestMessage_Oneofgroup struct {
	Oneofgroup *FieldTestMessage_OneofGroup `protobuf:"group,618,opt,name=OneofGroup,json=oneofgroup,oneof"`
}

func (*FieldTestMessage_OneofBool) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofEnum) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofInt32) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofSint32) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofUint32) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofInt64) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofSint64) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofUint64) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofSfixed32) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofFixed32) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofFloat) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofSfixed64) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofFixed64) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofDouble) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofString) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_OneofBytes) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_Oneof_Message) isFieldTestMessage_OneofField() {}

func (*FieldTestMessage_Oneofgroup) isFieldTestMessage_OneofField() {}

func (m *FieldTestMessage) GetOneofField() isFieldTestMessage_OneofField {
	if m != nil {
		return m.OneofField
	}
	return nil
}

func (m *FieldTestMessage) GetOneofBool() bool {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofBool); ok {
		return x.OneofBool
	}
	return false
}

func (m *FieldTestMessage) GetOneofEnum() FieldTestMessage_Enum {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofEnum); ok {
		return x.OneofEnum
	}
	return FieldTestMessage_ZERO
}

func (m *FieldTestMessage) GetOneofInt32() int32 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofInt32); ok {
		return x.OneofInt32
	}
	return 0
}

func (m *FieldTestMessage) GetOneofSint32() int32 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofSint32); ok {
		return x.OneofSint32
	}
	return 0
}

func (m *FieldTestMessage) GetOneofUint32() uint32 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofUint32); ok {
		return x.OneofUint32
	}
	return 0
}

func (m *FieldTestMessage) GetOneofInt64() int64 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofInt64); ok {
		return x.OneofInt64
	}
	return 0
}

func (m *FieldTestMessage) GetOneofSint64() int64 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofSint64); ok {
		return x.OneofSint64
	}
	return 0
}

func (m *FieldTestMessage) GetOneofUint64() uint64 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofUint64); ok {
		return x.OneofUint64
	}
	return 0
}

func (m *FieldTestMessage) GetOneofSfixed32() int32 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofSfixed32); ok {
		return x.OneofSfixed32
	}
	return 0
}

func (m *FieldTestMessage) GetOneofFixed32() uint32 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofFixed32); ok {
		return x.OneofFixed32
	}
	return 0
}

func (m *FieldTestMessage) GetOneofFloat() float32 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofFloat); ok {
		return x.OneofFloat
	}
	return 0
}

func (m *FieldTestMessage) GetOneofSfixed64() int64 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofSfixed64); ok {
		return x.OneofSfixed64
	}
	return 0
}

func (m *FieldTestMessage) GetOneofFixed64() uint64 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofFixed64); ok {
		return x.OneofFixed64
	}
	return 0
}

func (m *FieldTestMessage) GetOneofDouble() float64 {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofDouble); ok {
		return x.OneofDouble
	}
	return 0
}

func (m *FieldTestMessage) GetOneofString() string {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofString); ok {
		return x.OneofString
	}
	return ""
}

func (m *FieldTestMessage) GetOneofBytes() []byte {
	if x, ok := m.GetOneofField().(*FieldTestMessage_OneofBytes); ok {
		return x.OneofBytes
	}
	return nil
}

func (m *FieldTestMessage) GetOneof_Message() *FieldTestMessage_Message {
	if x, ok := m.GetOneofField().(*FieldTestMessage_Oneof_Message); ok {
		return x.Oneof_Message
	}
	return nil
}

func (m *FieldTestMessage) GetOneofgroup() *FieldTestMessage_OneofGroup {
	if x, ok := m.GetOneofField().(*FieldTestMessage_Oneofgroup); ok {
		return x.Oneofgroup
	}
	return nil
}

type isFieldTestMessage_OneofTwo interface {
	isFieldTestMessage_OneofTwo()
}

type FieldTestMessage_OneofTwo_1 struct {
	OneofTwo_1 int32 `protobuf:"varint,700,opt,name=oneof_two_1,json=oneofTwo1,oneof"`
}

type FieldTestMessage_OneofTwo_2 struct {
	OneofTwo_2 int64 `protobuf:"varint,701,opt,name=oneof_two_2,json=oneofTwo2,oneof"`
}

func (*FieldTestMessage_OneofTwo_1) isFieldTestMessage_OneofTwo() {}

func (*FieldTestMessage_OneofTwo_2) isFieldTestMessage_OneofTwo() {}

func (m *FieldTestMessage) GetOneofTwo() isFieldTestMessage_OneofTwo {
	if m != nil {
		return m.OneofTwo
	}
	return nil
}

func (m *FieldTestMessage) GetOneofTwo_1() int32 {
	if x, ok := m.GetOneofTwo().(*FieldTestMessage_OneofTwo_1); ok {
		return x.OneofTwo_1
	}
	return 0
}

func (m *FieldTestMessage) GetOneofTwo_2() int64 {
	if x, ok := m.GetOneofTwo().(*FieldTestMessage_OneofTwo_2); ok {
		return x.OneofTwo_2
	}
	return 0
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*FieldTestMessage) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _FieldTestMessage_OneofMarshaler, _FieldTestMessage_OneofUnmarshaler, _FieldTestMessage_OneofSizer, []interface{}{
		(*FieldTestMessage_OneofBool)(nil),
		(*FieldTestMessage_OneofEnum)(nil),
		(*FieldTestMessage_OneofInt32)(nil),
		(*FieldTestMessage_OneofSint32)(nil),
		(*FieldTestMessage_OneofUint32)(nil),
		(*FieldTestMessage_OneofInt64)(nil),
		(*FieldTestMessage_OneofSint64)(nil),
		(*FieldTestMessage_OneofUint64)(nil),
		(*FieldTestMessage_OneofSfixed32)(nil),
		(*FieldTestMessage_OneofFixed32)(nil),
		(*FieldTestMessage_OneofFloat)(nil),
		(*FieldTestMessage_OneofSfixed64)(nil),
		(*FieldTestMessage_OneofFixed64)(nil),
		(*FieldTestMessage_OneofDouble)(nil),
		(*FieldTestMessage_OneofString)(nil),
		(*FieldTestMessage_OneofBytes)(nil),
		(*FieldTestMessage_Oneof_Message)(nil),
		(*FieldTestMessage_Oneofgroup)(nil),
		(*FieldTestMessage_OneofTwo_1)(nil),
		(*FieldTestMessage_OneofTwo_2)(nil),
	}
}

func _FieldTestMessage_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*FieldTestMessage)
	// oneof_field
	switch x := m.OneofField.(type) {
	case *FieldTestMessage_OneofBool:
		t := uint64(0)
		if x.OneofBool {
			t = 1
		}
		b.EncodeVarint(601<<3 | proto.WireVarint)
		b.EncodeVarint(t)
	case *FieldTestMessage_OneofEnum:
		b.EncodeVarint(602<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.OneofEnum))
	case *FieldTestMessage_OneofInt32:
		b.EncodeVarint(603<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.OneofInt32))
	case *FieldTestMessage_OneofSint32:
		b.EncodeVarint(604<<3 | proto.WireVarint)
		b.EncodeZigzag32(uint64(x.OneofSint32))
	case *FieldTestMessage_OneofUint32:
		b.EncodeVarint(605<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.OneofUint32))
	case *FieldTestMessage_OneofInt64:
		b.EncodeVarint(606<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.OneofInt64))
	case *FieldTestMessage_OneofSint64:
		b.EncodeVarint(607<<3 | proto.WireVarint)
		b.EncodeZigzag64(uint64(x.OneofSint64))
	case *FieldTestMessage_OneofUint64:
		b.EncodeVarint(608<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.OneofUint64))
	case *FieldTestMessage_OneofSfixed32:
		b.EncodeVarint(609<<3 | proto.WireFixed32)
		b.EncodeFixed32(uint64(x.OneofSfixed32))
	case *FieldTestMessage_OneofFixed32:
		b.EncodeVarint(610<<3 | proto.WireFixed32)
		b.EncodeFixed32(uint64(x.OneofFixed32))
	case *FieldTestMessage_OneofFloat:
		b.EncodeVarint(611<<3 | proto.WireFixed32)
		b.EncodeFixed32(uint64(math.Float32bits(x.OneofFloat)))
	case *FieldTestMessage_OneofSfixed64:
		b.EncodeVarint(612<<3 | proto.WireFixed64)
		b.EncodeFixed64(uint64(x.OneofSfixed64))
	case *FieldTestMessage_OneofFixed64:
		b.EncodeVarint(613<<3 | proto.WireFixed64)
		b.EncodeFixed64(uint64(x.OneofFixed64))
	case *FieldTestMessage_OneofDouble:
		b.EncodeVarint(614<<3 | proto.WireFixed64)
		b.EncodeFixed64(math.Float64bits(x.OneofDouble))
	case *FieldTestMessage_OneofString:
		b.EncodeVarint(615<<3 | proto.WireBytes)
		b.EncodeStringBytes(x.OneofString)
	case *FieldTestMessage_OneofBytes:
		b.EncodeVarint(616<<3 | proto.WireBytes)
		b.EncodeRawBytes(x.OneofBytes)
	case *FieldTestMessage_Oneof_Message:
		b.EncodeVarint(617<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Oneof_Message); err != nil {
			return err
		}
	case *FieldTestMessage_Oneofgroup:
		b.EncodeVarint(618<<3 | proto.WireStartGroup)
		if err := b.Marshal(x.Oneofgroup); err != nil {
			return err
		}
		b.EncodeVarint(618<<3 | proto.WireEndGroup)
	case nil:
	default:
		return fmt.Errorf("FieldTestMessage.OneofField has unexpected type %T", x)
	}
	// oneof_two
	switch x := m.OneofTwo.(type) {
	case *FieldTestMessage_OneofTwo_1:
		b.EncodeVarint(700<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.OneofTwo_1))
	case *FieldTestMessage_OneofTwo_2:
		b.EncodeVarint(701<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.OneofTwo_2))
	case nil:
	default:
		return fmt.Errorf("FieldTestMessage.OneofTwo has unexpected type %T", x)
	}
	return nil
}

func _FieldTestMessage_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*FieldTestMessage)
	switch tag {
	case 601: // oneof_field.oneof_bool
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofField = &FieldTestMessage_OneofBool{x != 0}
		return true, err
	case 602: // oneof_field.oneof_enum
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofField = &FieldTestMessage_OneofEnum{FieldTestMessage_Enum(x)}
		return true, err
	case 603: // oneof_field.oneof_int32
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofField = &FieldTestMessage_OneofInt32{int32(x)}
		return true, err
	case 604: // oneof_field.oneof_sint32
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeZigzag32()
		m.OneofField = &FieldTestMessage_OneofSint32{int32(x)}
		return true, err
	case 605: // oneof_field.oneof_uint32
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofField = &FieldTestMessage_OneofUint32{uint32(x)}
		return true, err
	case 606: // oneof_field.oneof_int64
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofField = &FieldTestMessage_OneofInt64{int64(x)}
		return true, err
	case 607: // oneof_field.oneof_sint64
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeZigzag64()
		m.OneofField = &FieldTestMessage_OneofSint64{int64(x)}
		return true, err
	case 608: // oneof_field.oneof_uint64
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofField = &FieldTestMessage_OneofUint64{x}
		return true, err
	case 609: // oneof_field.oneof_sfixed32
		if wire != proto.WireFixed32 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed32()
		m.OneofField = &FieldTestMessage_OneofSfixed32{int32(x)}
		return true, err
	case 610: // oneof_field.oneof_fixed32
		if wire != proto.WireFixed32 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed32()
		m.OneofField = &FieldTestMessage_OneofFixed32{uint32(x)}
		return true, err
	case 611: // oneof_field.oneof_float
		if wire != proto.WireFixed32 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed32()
		m.OneofField = &FieldTestMessage_OneofFloat{math.Float32frombits(uint32(x))}
		return true, err
	case 612: // oneof_field.oneof_sfixed64
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.OneofField = &FieldTestMessage_OneofSfixed64{int64(x)}
		return true, err
	case 613: // oneof_field.oneof_fixed64
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.OneofField = &FieldTestMessage_OneofFixed64{x}
		return true, err
	case 614: // oneof_field.oneof_double
		if wire != proto.WireFixed64 {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeFixed64()
		m.OneofField = &FieldTestMessage_OneofDouble{math.Float64frombits(x)}
		return true, err
	case 615: // oneof_field.oneof_string
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.OneofField = &FieldTestMessage_OneofString{x}
		return true, err
	case 616: // oneof_field.oneof_bytes
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeRawBytes(true)
		m.OneofField = &FieldTestMessage_OneofBytes{x}
		return true, err
	case 617: // oneof_field.oneof_Message
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(FieldTestMessage_Message)
		err := b.DecodeMessage(msg)
		m.OneofField = &FieldTestMessage_Oneof_Message{msg}
		return true, err
	case 618: // oneof_field.oneofgroup
		if wire != proto.WireStartGroup {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(FieldTestMessage_OneofGroup)
		err := b.DecodeGroup(msg)
		m.OneofField = &FieldTestMessage_Oneofgroup{msg}
		return true, err
	case 700: // oneof_two.oneof_two_1
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofTwo = &FieldTestMessage_OneofTwo_1{int32(x)}
		return true, err
	case 701: // oneof_two.oneof_two_2
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofTwo = &FieldTestMessage_OneofTwo_2{int64(x)}
		return true, err
	default:
		return false, nil
	}
}

func _FieldTestMessage_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*FieldTestMessage)
	// oneof_field
	switch x := m.OneofField.(type) {
	case *FieldTestMessage_OneofBool:
		n += 2 // tag and wire
		n += 1
	case *FieldTestMessage_OneofEnum:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.OneofEnum))
	case *FieldTestMessage_OneofInt32:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.OneofInt32))
	case *FieldTestMessage_OneofSint32:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64((uint32(x.OneofSint32) << 1) ^ uint32((int32(x.OneofSint32) >> 31))))
	case *FieldTestMessage_OneofUint32:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.OneofUint32))
	case *FieldTestMessage_OneofInt64:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.OneofInt64))
	case *FieldTestMessage_OneofSint64:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(uint64(x.OneofSint64<<1) ^ uint64((int64(x.OneofSint64) >> 63))))
	case *FieldTestMessage_OneofUint64:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.OneofUint64))
	case *FieldTestMessage_OneofSfixed32:
		n += 2 // tag and wire
		n += 4
	case *FieldTestMessage_OneofFixed32:
		n += 2 // tag and wire
		n += 4
	case *FieldTestMessage_OneofFloat:
		n += 2 // tag and wire
		n += 4
	case *FieldTestMessage_OneofSfixed64:
		n += 2 // tag and wire
		n += 8
	case *FieldTestMessage_OneofFixed64:
		n += 2 // tag and wire
		n += 8
	case *FieldTestMessage_OneofDouble:
		n += 2 // tag and wire
		n += 8
	case *FieldTestMessage_OneofString:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(len(x.OneofString)))
		n += len(x.OneofString)
	case *FieldTestMessage_OneofBytes:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(len(x.OneofBytes)))
		n += len(x.OneofBytes)
	case *FieldTestMessage_Oneof_Message:
		s := proto.Size(x.Oneof_Message)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *FieldTestMessage_Oneofgroup:
		n += 2 // tag and wire
		n += proto.Size(x.Oneofgroup)
		n += 2 // tag and wire
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	// oneof_two
	switch x := m.OneofTwo.(type) {
	case *FieldTestMessage_OneofTwo_1:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.OneofTwo_1))
	case *FieldTestMessage_OneofTwo_2:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.OneofTwo_2))
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

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_OneofGroup struct {
	OneofGroupField      *string  `protobuf:"bytes,619,opt,name=oneof_group_field,json=oneofGroupField" json:"oneof_group_field,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FieldTestMessage_OneofGroup) Reset()         { *m = FieldTestMessage_OneofGroup{} }
func (m *FieldTestMessage_OneofGroup) String() string { return proto.CompactTextString(m) }
func (*FieldTestMessage_OneofGroup) ProtoMessage()    {}
func (*FieldTestMessage_OneofGroup) Descriptor() ([]byte, []int) {
	return fileDescriptor_fd8a9d72b841fd68, []int{0, 6}
}

func (m *FieldTestMessage_OneofGroup) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldTestMessage_OneofGroup.Unmarshal(m, b)
}
func (m *FieldTestMessage_OneofGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldTestMessage_OneofGroup.Marshal(b, m, deterministic)
}
func (m *FieldTestMessage_OneofGroup) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldTestMessage_OneofGroup.Merge(m, src)
}
func (m *FieldTestMessage_OneofGroup) XXX_Size() int {
	return xxx_messageInfo_FieldTestMessage_OneofGroup.Size(m)
}
func (m *FieldTestMessage_OneofGroup) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldTestMessage_OneofGroup.DiscardUnknown(m)
}

var xxx_messageInfo_FieldTestMessage_OneofGroup proto.InternalMessageInfo

func (m *FieldTestMessage_OneofGroup) GetOneofGroupField() string {
	if m != nil && m.OneofGroupField != nil {
		return *m.OneofGroupField
	}
	return ""
}

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, 7}
}

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.RegisterEnum("goproto.protoc.proto2.FieldTestMessage_Enum", FieldTestMessage_Enum_name, FieldTestMessage_Enum_value)
	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_OneofGroup)(nil), "goproto.protoc.proto2.FieldTestMessage.OneofGroup")
	proto.RegisterType((*FieldTestMessage_Message)(nil), "goproto.protoc.proto2.FieldTestMessage.Message")
}

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

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