internal/impl: derive descriptors for legacy enums and messages

In order for the v2 rollout to be as seamless as possible, we need to support
the situation where a v2 message depends on some other generated v1 message that
may be stale and does not support the v2 API. In such a situation, there needs
to be some way to wrap a legacy message or enum in such a way that it satisfies
the v2 API.

This wrapping is comprised of two parts:
1) Deriving an enum or message descriptor
2) Providing an reflection implementation for messages

This CL addresses part 1 (while part 2 has already been partially implemented,
since the implementation applies to both v1 and v2).

To derive the enum and message descriptor we rely on a mixture of parsing the
raw descriptor proto and also introspection on the fields in the message.
Methods for obtaining the raw descriptor protos were added in February, 2016,
and so has not always been available. For that reason, we attempt to derive
as much information from the Go type as possible.

As part of this change, we modify prototype to be able to create multiple
standalone messages as a set. This is needed since cyclic dependencies is allowed
between messages within a single proto file.

Change-Id: I71aaf5f977faf9fba03c370b1ee17b3758ce60a6
Reviewed-on: https://go-review.googlesource.com/c/143539
Reviewed-by: Damien Neil <dneil@google.com>

internal/impl/legacy_enum.go

@@ -0,0 +1,97 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package impl
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"sync"
+
+	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+	ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+var enumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
+
+// loadEnumDesc returns an EnumDescriptor derived from the Go type,
+// which must be an int32 kind and not implement the v2 API already.
+func loadEnumDesc(t reflect.Type) pref.EnumDescriptor {
+	// Fast-path: check if an EnumDescriptor is cached for this concrete type.
+	if v, ok := enumDescCache.Load(t); ok {
+		return v.(pref.EnumDescriptor)
+	}
+
+	// Slow-path: initialize EnumDescriptor from the proto descriptor.
+	if t.Kind() != reflect.Int32 {
+		panic(fmt.Sprintf("got %v, want int32 kind", t))
+	}
+
+	// Derive the enum descriptor from the raw descriptor proto.
+	e := new(ptype.StandaloneEnum)
+	ev := reflect.Zero(t).Interface()
+	if _, ok := ev.(pref.ProtoEnum); ok {
+		panic(fmt.Sprintf("%v already implements proto.Enum", t))
+	}
+	if ed, ok := ev.(legacyEnum); ok {
+		b, idxs := ed.EnumDescriptor()
+		fd := loadFileDesc(b)
+
+		// Derive syntax.
+		switch fd.GetSyntax() {
+		case "proto2", "":
+			e.Syntax = pref.Proto2
+		case "proto3":
+			e.Syntax = pref.Proto3
+		}
+
+		// Derive the full name and correct enum descriptor.
+		var ed *descriptorV1.EnumDescriptorProto
+		e.FullName = pref.FullName(fd.GetPackage())
+		if len(idxs) == 1 {
+			ed = fd.EnumType[idxs[0]]
+			e.FullName = e.FullName.Append(pref.Name(ed.GetName()))
+		} else {
+			md := fd.MessageType[idxs[0]]
+			e.FullName = e.FullName.Append(pref.Name(md.GetName()))
+			for _, i := range idxs[1 : len(idxs)-1] {
+				md = md.NestedType[i]
+				e.FullName = e.FullName.Append(pref.Name(md.GetName()))
+			}
+			ed = md.EnumType[idxs[len(idxs)-1]]
+			e.FullName = e.FullName.Append(pref.Name(ed.GetName()))
+		}
+
+		// Derive the enum values.
+		for _, vd := range ed.GetValue() {
+			e.Values = append(e.Values, ptype.EnumValue{
+				Name:   pref.Name(vd.GetName()),
+				Number: pref.EnumNumber(vd.GetNumber()),
+			})
+		}
+	} else {
+		// If the type does not implement legacyEnum, then there is no reliable
+		// way to derive the original protobuf type information.
+		// We are unable to use the global enum registry since it is
+		// unfortunately keyed by the full name, which we do not know.
+		// Furthermore, some generated enums register with a fork of
+		// golang/protobuf so the enum may not even be found in the registry.
+		//
+		// Instead, create a bogus enum descriptor to ensure that
+		// most operations continue to work. For example, textpb and jsonpb
+		// will be unable to parse a message with an enum value by name.
+		e.Syntax = pref.Proto2
+		e.FullName = deriveFullName(t)
+		e.Values = []ptype.EnumValue{{Name: "INVALID", Number: math.MinInt32}}
+	}
+
+	ed, err := ptype.NewEnum(e)
+	if err != nil {
+		panic(err)
+	}
+	enumDescCache.Store(t, ed)
+	return ed
+}

internal/impl/legacy_file.go

@@ -0,0 +1,68 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package impl
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io/ioutil"
+	"sync"
+
+	// TODO: Avoid reliance on old API. However, there is currently a
+	// chicken and egg problem where we need the descriptor protos to implement
+	// the new API.
+	protoV1 "github.com/golang/protobuf/proto"
+	descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+)
+
+// Every enum and message type generated by protoc-gen-go since commit 2fc053c5
+// on February 25th, 2016 has had a method to get the raw descriptor.
+// Types that were not generated by protoc-gen-go or were generated prior
+// to that version are not supported.
+//
+// The []byte returned is the encoded form of a FileDescriptorProto message
+// compressed using GZIP. The []int is the path from the top-level file
+// to the specific message or enum declaration.
+type (
+	legacyEnum interface {
+		EnumDescriptor() ([]byte, []int)
+	}
+	legacyMessage interface {
+		Descriptor() ([]byte, []int)
+	}
+)
+
+var fileDescCache sync.Map // map[*byte]*descriptorV1.FileDescriptorProto
+
+// loadFileDesc unmarshals b as a compressed FileDescriptorProto message.
+//
+// This assumes that b is immutable and that b does not refer to part of a
+// concatenated series of GZIP files (which would require shenanigans that
+// rely on the concatenation properties of both protobufs and GZIP).
+// File descriptors generated by protoc-gen-go do not rely on that property.
+func loadFileDesc(b []byte) *descriptorV1.FileDescriptorProto {
+	// Fast-path: check whether we already have a cached file descriptor.
+	if v, ok := fileDescCache.Load(&b[0]); ok {
+		return v.(*descriptorV1.FileDescriptorProto)
+	}
+
+	// Slow-path: decompress and unmarshal the file descriptor proto.
+	m := new(descriptorV1.FileDescriptorProto)
+	zr, err := gzip.NewReader(bytes.NewReader(b))
+	if err != nil {
+		panic(err)
+	}
+	b, err = ioutil.ReadAll(zr)
+	if err != nil {
+		panic(err)
+	}
+	// TODO: What about extensions?
+	// The protoV1 API does not eagerly unmarshal extensions.
+	if err := protoV1.Unmarshal(b, m); err != nil {
+		panic(err)
+	}
+	fileDescCache.Store(&b[0], m)
+	return m
+}

internal/impl/legacy_message.go

@@ -0,0 +1,412 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package impl
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+
+	"github.com/golang/protobuf/v2/internal/encoding/text"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+	ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
+
+// loadMessageDesc returns an MessageDescriptor derived from the Go type,
+// which must be an *struct kind and not implement the v2 API already.
+func loadMessageDesc(t reflect.Type) pref.MessageDescriptor {
+	return messageDescSet{}.Load(t)
+}
+
+type messageDescSet struct {
+	visited map[reflect.Type]*ptype.StandaloneMessage
+	descs   []*ptype.StandaloneMessage
+	types   []reflect.Type
+}
+
+func (ms messageDescSet) Load(t reflect.Type) pref.MessageDescriptor {
+	// Fast-path: check if a MessageDescriptor is cached for this concrete type.
+	if mi, ok := messageDescCache.Load(t); ok {
+		return mi.(pref.MessageDescriptor)
+	}
+
+	// Slow-path: initialize MessageDescriptor from the Go type.
+
+	// Processing t recursively populates descs and types with all sub-messages.
+	// The descriptor for the first type is guaranteed to be at the front.
+	ms.processMessage(t)
+
+	// Within a proto file it is possible for cyclic dependencies to exist
+	// between multiple message types. When these cases arise, the set of
+	// message descriptors must be created together.
+	mds, err := ptype.NewMessages(ms.descs)
+	if err != nil {
+		panic(err)
+	}
+	for i, md := range mds {
+		// Protobuf semantics represents map entries under-the-hood as
+		// pseudo-messages (has a descriptor, but no generated Go type).
+		// Avoid caching these fake messages.
+		if t := ms.types[i]; t.Kind() != reflect.Map {
+			messageDescCache.Store(t, md)
+		}
+	}
+	return mds[0]
+}
+
+func (ms *messageDescSet) processMessage(t reflect.Type) pref.MessageDescriptor {
+	// Fast-path: Obtain a placeholder if the message is already processed.
+	if m, ok := ms.visited[t]; ok {
+		return ptype.PlaceholderMessage(m.FullName)
+	}
+
+	// Slow-path: Walk over the struct fields to derive the message descriptor.
+	if t.Kind() != reflect.Ptr && t.Elem().Kind() != reflect.Struct {
+		panic(fmt.Sprintf("got %v, want *struct kind", t))
+	}
+
+	// Derive name and syntax from the raw descriptor.
+	m := new(ptype.StandaloneMessage)
+	mv := reflect.New(t.Elem()).Interface()
+	if _, ok := mv.(pref.ProtoMessage); ok {
+		panic(fmt.Sprintf("%v already implements proto.Message", t))
+	}
+	if md, ok := mv.(legacyMessage); ok {
+		b, idxs := md.Descriptor()
+		fd := loadFileDesc(b)
+
+		// Derive syntax.
+		switch fd.GetSyntax() {
+		case "proto2", "":
+			m.Syntax = pref.Proto2
+		case "proto3":
+			m.Syntax = pref.Proto3
+		}
+
+		// Derive full name.
+		md := fd.MessageType[idxs[0]]
+		m.FullName = pref.FullName(fd.GetPackage()).Append(pref.Name(md.GetName()))
+		for _, i := range idxs[1:] {
+			md = md.NestedType[i]
+			m.FullName = m.FullName.Append(pref.Name(md.GetName()))
+		}
+	} else {
+		// If the type does not implement legacyMessage, then the only way to
+		// obtain the full name is through the registry. However, this is
+		// unreliable as some generated messages register with a fork of
+		// golang/protobuf, so the registry may not have this information.
+		m.FullName = deriveFullName(t.Elem())
+		m.Syntax = pref.Proto2
+
+		// Try to determine if the message is using proto3 by checking scalars.
+		for i := 0; i < t.Elem().NumField(); i++ {
+			f := t.Elem().Field(i)
+			if tag := f.Tag.Get("protobuf"); tag != "" {
+				switch f.Type.Kind() {
+				case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+					m.Syntax = pref.Proto3
+				}
+				for _, s := range strings.Split(tag, ",") {
+					if s == "proto3" {
+						m.Syntax = pref.Proto3
+					}
+				}
+			}
+		}
+	}
+	ms.visit(m, t)
+
+	// Obtain a list of oneof wrapper types.
+	var oneofWrappers []reflect.Type
+	if fn, ok := t.MethodByName("XXX_OneofFuncs"); ok {
+		vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3]
+		for _, v := range vs.Interface().([]interface{}) {
+			oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
+		}
+	}
+
+	// Obtain a list of the extension ranges.
+	if fn, ok := t.MethodByName("ExtensionRangeArray"); ok {
+		vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
+		for i := 0; i < vs.Len(); i++ {
+			v := vs.Index(i)
+			m.ExtensionRanges = append(m.ExtensionRanges, [2]pref.FieldNumber{
+				pref.FieldNumber(v.FieldByName("Start").Int()),
+				pref.FieldNumber(v.FieldByName("End").Int() + 1),
+			})
+		}
+	}
+
+	// Derive the message fields by inspecting the struct fields.
+	for i := 0; i < t.Elem().NumField(); i++ {
+		f := t.Elem().Field(i)
+		if tag := f.Tag.Get("protobuf"); tag != "" {
+			tagKey := f.Tag.Get("protobuf_key")
+			tagVal := f.Tag.Get("protobuf_val")
+			m.Fields = append(m.Fields, ms.parseField(tag, tagKey, tagVal, f.Type, m))
+		}
+		if tag := f.Tag.Get("protobuf_oneof"); tag != "" {
+			name := pref.Name(tag)
+			m.Oneofs = append(m.Oneofs, ptype.Oneof{Name: name})
+			for _, t := range oneofWrappers {
+				if t.Implements(f.Type) {
+					f := t.Elem().Field(0)
+					if tag := f.Tag.Get("protobuf"); tag != "" {
+						ft := ms.parseField(tag, "", "", f.Type, m)
+						ft.OneofName = name
+						m.Fields = append(m.Fields, ft)
+					}
+				}
+			}
+		}
+	}
+
+	return ptype.PlaceholderMessage(m.FullName)
+}
+
+func (ms *messageDescSet) parseField(tag, tagKey, tagVal string, t reflect.Type, parent *ptype.StandaloneMessage) (f ptype.Field) {
+	isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
+	isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+	if isOptional || isRepeated {
+		t = t.Elem()
+	}
+
+	for len(tag) > 0 {
+		i := strings.IndexByte(tag, ',')
+		if i < 0 {
+			i = len(tag)
+		}
+		switch s := tag[:i]; {
+		case strings.HasPrefix(s, "name="):
+			f.Name = pref.Name(s[len("name="):])
+		case strings.Trim(s, "0123456789") == "":
+			n, _ := strconv.ParseUint(s, 10, 32)
+			f.Number = pref.FieldNumber(n)
+		case s == "opt":
+			f.Cardinality = pref.Optional
+		case s == "req":
+			f.Cardinality = pref.Required
+		case s == "rep":
+			f.Cardinality = pref.Repeated
+		case s == "varint":
+			switch t.Kind() {
+			case reflect.Bool:
+				f.Kind = pref.BoolKind
+			case reflect.Int32:
+				f.Kind = pref.Int32Kind
+			case reflect.Int64:
+				f.Kind = pref.Int64Kind
+			case reflect.Uint32:
+				f.Kind = pref.Uint32Kind
+			case reflect.Uint64:
+				f.Kind = pref.Uint64Kind
+			}
+		case s == "zigzag32":
+			if t.Kind() == reflect.Int32 {
+				f.Kind = pref.Sint32Kind
+			}
+		case s == "zigzag64":
+			if t.Kind() == reflect.Int64 {
+				f.Kind = pref.Sint64Kind
+			}
+		case s == "fixed32":
+			switch t.Kind() {
+			case reflect.Int32:
+				f.Kind = pref.Sfixed32Kind
+			case reflect.Uint32:
+				f.Kind = pref.Fixed32Kind
+			case reflect.Float32:
+				f.Kind = pref.FloatKind
+			}
+		case s == "fixed64":
+			switch t.Kind() {
+			case reflect.Int64:
+				f.Kind = pref.Sfixed64Kind
+			case reflect.Uint64:
+				f.Kind = pref.Fixed64Kind
+			case reflect.Float64:
+				f.Kind = pref.DoubleKind
+			}
+		case s == "bytes":
+			switch {
+			case t.Kind() == reflect.String:
+				f.Kind = pref.StringKind
+			case t.Kind() == reflect.Slice && t.Elem() == byteType:
+				f.Kind = pref.BytesKind
+			default:
+				f.Kind = pref.MessageKind
+			}
+		case s == "group":
+			f.Kind = pref.GroupKind
+		case strings.HasPrefix(s, "enum="):
+			f.Kind = pref.EnumKind
+		case strings.HasPrefix(s, "json="):
+			f.JSONName = s[len("json="):]
+		case s == "packed":
+			f.IsPacked = true
+		case strings.HasPrefix(s, "weak="):
+			f.IsWeak = true
+			f.MessageType = ptype.PlaceholderMessage(pref.FullName(s[len("weak="):]))
+		case strings.HasPrefix(s, "def="):
+			// The default tag is special in that everything afterwards is the
+			// default regardless of the presence of commas.
+			s, i = tag[len("def="):], len(tag)
+
+			// Defaults are parsed last, so Kind is populated.
+			switch f.Kind {
+			case pref.BoolKind:
+				switch s {
+				case "1":
+					f.Default = pref.ValueOf(true)
+				case "0":
+					f.Default = pref.ValueOf(false)
+				}
+			case pref.EnumKind:
+				n, _ := strconv.ParseInt(s, 10, 32)
+				f.Default = pref.ValueOf(pref.EnumNumber(n))
+			case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+				n, _ := strconv.ParseInt(s, 10, 32)
+				f.Default = pref.ValueOf(int32(n))
+			case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+				n, _ := strconv.ParseInt(s, 10, 64)
+				f.Default = pref.ValueOf(int64(n))
+			case pref.Uint32Kind, pref.Fixed32Kind:
+				n, _ := strconv.ParseUint(s, 10, 32)
+				f.Default = pref.ValueOf(uint32(n))
+			case pref.Uint64Kind, pref.Fixed64Kind:
+				n, _ := strconv.ParseUint(s, 10, 64)
+				f.Default = pref.ValueOf(uint64(n))
+			case pref.FloatKind, pref.DoubleKind:
+				n, _ := strconv.ParseFloat(s, 64)
+				switch s {
+				case "nan":
+					n = math.NaN()
+				case "inf":
+					n = math.Inf(+1)
+				case "-inf":
+					n = math.Inf(-1)
+				}
+				if f.Kind == pref.FloatKind {
+					f.Default = pref.ValueOf(float32(n))
+				} else {
+					f.Default = pref.ValueOf(float64(n))
+				}
+			case pref.StringKind:
+				f.Default = pref.ValueOf(string(s))
+			case pref.BytesKind:
+				// The default value is in escaped form (C-style).
+				// TODO: Export unmarshalString in the text package to avoid this hack.
+				v, err := text.Unmarshal([]byte(`["` + s + `"]:0`))
+				if err == nil && len(v.Message()) == 1 {
+					s := v.Message()[0][0].String()
+					f.Default = pref.ValueOf([]byte(s))
+				}
+			}
+		}
+		tag = strings.TrimPrefix(tag[i:], ",")
+	}
+
+	// The generator uses the group message name instead of the field name.
+	// We obtain the real field name by lowercasing the group name.
+	if f.Kind == pref.GroupKind {
+		f.Name = pref.Name(strings.ToLower(string(f.Name)))
+	}
+
+	// Populate EnumType and MessageType.
+	if f.EnumType == nil && f.Kind == pref.EnumKind {
+		if ev, ok := reflect.Zero(t).Interface().(pref.ProtoEnum); ok {
+			f.EnumType = ev.ProtoReflect().Type()
+		} else {
+			f.EnumType = loadEnumDesc(t)
+		}
+	}
+	if f.MessageType == nil && (f.Kind == pref.MessageKind || f.Kind == pref.GroupKind) {
+		if mv, ok := reflect.Zero(t).Interface().(pref.ProtoMessage); ok {
+			f.MessageType = mv.ProtoReflect().Type()
+		} else if t.Kind() == reflect.Map {
+			m := &ptype.StandaloneMessage{
+				Syntax:     parent.Syntax,
+				FullName:   parent.FullName.Append(mapEntryName(f.Name)),
+				IsMapEntry: true,
+				Fields: []ptype.Field{
+					ms.parseField(tagKey, "", "", t.Key(), nil),
+					ms.parseField(tagVal, "", "", t.Elem(), nil),
+				},
+			}
+			ms.visit(m, t)
+			f.MessageType = ptype.PlaceholderMessage(m.FullName)
+		} else if mv, ok := messageDescCache.Load(t); ok {
+			f.MessageType = mv.(pref.MessageDescriptor)
+		} else {
+			f.MessageType = ms.processMessage(t)
+		}
+	}
+	return f
+}
+
+func (ms *messageDescSet) visit(m *ptype.StandaloneMessage, t reflect.Type) {
+	if ms.visited == nil {
+		ms.visited = make(map[reflect.Type]*ptype.StandaloneMessage)
+	}
+	if t.Kind() != reflect.Map {
+		ms.visited[t] = m
+	}
+	ms.descs = append(ms.descs, m)
+	ms.types = append(ms.types, t)
+}
+
+// deriveFullName derives a fully qualified protobuf name for the given Go type
+// The provided name is not guaranteed to be stable nor universally unique.
+// It should be sufficiently unique within a program.
+func deriveFullName(t reflect.Type) pref.FullName {
+	sanitize := func(r rune) rune {
+		switch {
+		case r == '/':
+			return '.'
+		case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
+			return r
+		default:
+			return '_'
+		}
+	}
+	prefix := strings.Map(sanitize, t.PkgPath())
+	suffix := strings.Map(sanitize, t.Name())
+	if suffix == "" {
+		suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
+	}
+
+	ss := append(strings.Split(prefix, "."), suffix)
+	for i, s := range ss {
+		if s == "" || ('0' <= s[0] && s[0] <= '9') {
+			ss[i] = "x" + s
+		}
+	}
+	return pref.FullName(strings.Join(ss, "."))
+}
+
+// mapEntryName derives the message name for a map field of a given name.
+// This is identical to MapEntryName from parser.cc in the protoc source.
+func mapEntryName(s pref.Name) pref.Name {
+	var b []byte
+	nextUpper := true
+	for i := 0; i < len(s); i++ {
+		if c := s[i]; c == '_' {
+			nextUpper = true
+		} else {
+			if nextUpper {
+				c = byte(unicode.ToUpper(rune(c)))
+				nextUpper = false
+			}
+			b = append(b, c)
+		}
+	}
+	return pref.Name(append(b, "Entry"...))
+}

internal/impl/legacy_proto2_test.go

@@ -0,0 +1,759 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package impl
+
+// TODO: Move this to a separate package. We do *not* want this to be
+// auto-generated by the current protoc-gen-go since it is supposed to be a
+// snapshot of an generated message from the past.
+
+import "github.com/golang/protobuf/proto"
+
+type LP2MapEnum int32
+
+func (LP2MapEnum) EnumDescriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{0}
+}
+
+type LP2SiblingEnum int32
+
+func (LP2SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1}
+}
+
+type LP2Message_LP2ChildEnum int32
+
+func (LP2Message_LP2ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1, 0}
+}
+
+type LP2SiblingMessage struct {
+	F1                   *string  `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   *string  `protobuf:"bytes,2,req,name=f2" json:"f2,omitempty"`
+	F3                   []string `protobuf:"bytes,3,rep,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP2SiblingMessage) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{0}
+}
+
+type LP2Message struct {
+	Lp2Namedgroup *LP2Message_LP2NamedGroup `protobuf:"group,1,opt,name=LP2NamedGroup,json=lp2namedgroup" json:"lp2namedgroup,omitempty"`
+	// Optional fields.
+	OptionalBool           *bool                       `protobuf:"varint,100,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
+	OptionalInt32          *int32                      `protobuf:"varint,101,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
+	OptionalSint32         *int32                      `protobuf:"zigzag32,102,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
+	OptionalUint32         *uint32                     `protobuf:"varint,103,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
+	OptionalInt64          *int64                      `protobuf:"varint,104,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
+	OptionalSint64         *int64                      `protobuf:"zigzag64,105,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
+	OptionalUint64         *uint64                     `protobuf:"varint,106,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
+	OptionalFixed32        *uint32                     `protobuf:"fixed32,107,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
+	OptionalSfixed32       *int32                      `protobuf:"fixed32,108,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
+	OptionalFloat          *float32                    `protobuf:"fixed32,109,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
+	OptionalFixed64        *uint64                     `protobuf:"fixed64,110,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
+	OptionalSfixed64       *int64                      `protobuf:"fixed64,111,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
+	OptionalDouble         *float64                    `protobuf:"fixed64,112,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
+	OptionalString         *string                     `protobuf:"bytes,113,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
+	OptionalBytes          []byte                      `protobuf:"bytes,114,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
+	OptionalChildEnum      *LP2Message_LP2ChildEnum    `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,enum=google.golang.org.proto2.LP2Message_LP2ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalSiblingEnum    *LP2SiblingEnum             `protobuf:"varint,116,opt,name=optional_sibling_enum,json=optionalSiblingEnum,enum=google.golang.org.proto2.LP2SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalChildMessage   *LP2Message_LP2ChildMessage `protobuf:"bytes,117,opt,name=optional_child_message,json=optionalChildMessage" json:"optional_child_message,omitempty"`
+	OptionalSiblingMessage *LP2SiblingMessage          `protobuf:"bytes,118,opt,name=optional_sibling_message,json=optionalSiblingMessage" json:"optional_sibling_message,omitempty"`
+	OptionalNamedGroup     *LP2Message_LP2NamedGroup   `protobuf:"bytes,119,opt,name=optional_named_group,json=optionalNamedGroup" json:"optional_named_group,omitempty"`
+	Optionalgroup          *LP2Message_OptionalGroup   `protobuf:"group,120,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
+	// Optional default fields.
+	DefaultedBool        *bool                    `protobuf:"varint,200,opt,name=defaulted_bool,json=defaultedBool,def=1" json:"defaulted_bool,omitempty"`
+	DefaultedInt32       *int32                   `protobuf:"varint,201,opt,name=defaulted_int32,json=defaultedInt32,def=-12345" json:"defaulted_int32,omitempty"`
+	DefaultedSint32      *int32                   `protobuf:"zigzag32,202,opt,name=defaulted_sint32,json=defaultedSint32,def=-3200" json:"defaulted_sint32,omitempty"`
+	DefaultedUint32      *uint32                  `protobuf:"varint,203,opt,name=defaulted_uint32,json=defaultedUint32,def=3200" json:"defaulted_uint32,omitempty"`
+	DefaultedInt64       *int64                   `protobuf:"varint,204,opt,name=defaulted_int64,json=defaultedInt64,def=-123456789" json:"defaulted_int64,omitempty"`
+	DefaultedSint64      *int64                   `protobuf:"zigzag64,205,opt,name=defaulted_sint64,json=defaultedSint64,def=-6400" json:"defaulted_sint64,omitempty"`
+	DefaultedUint64      *uint64                  `protobuf:"varint,206,opt,name=defaulted_uint64,json=defaultedUint64,def=6400" json:"defaulted_uint64,omitempty"`
+	DefaultedFixed32     *uint32                  `protobuf:"fixed32,207,opt,name=defaulted_fixed32,json=defaultedFixed32,def=320000" json:"defaulted_fixed32,omitempty"`
+	DefaultedSfixed32    *int32                   `protobuf:"fixed32,208,opt,name=defaulted_sfixed32,json=defaultedSfixed32,def=-320000" json:"defaulted_sfixed32,omitempty"`
+	DefaultedFloat       *float32                 `protobuf:"fixed32,209,opt,name=defaulted_float,json=defaultedFloat,def=3.14159" json:"defaulted_float,omitempty"`
+	DefaultedFixed64     *uint64                  `protobuf:"fixed64,210,opt,name=defaulted_fixed64,json=defaultedFixed64,def=640000" json:"defaulted_fixed64,omitempty"`
+	DefaultedSfixed64    *int64                   `protobuf:"fixed64,211,opt,name=defaulted_sfixed64,json=defaultedSfixed64,def=-640000" json:"defaulted_sfixed64,omitempty"`
+	DefaultedDouble      *float64                 `protobuf:"fixed64,212,opt,name=defaulted_double,json=defaultedDouble,def=3.14159265359" json:"defaulted_double,omitempty"`
+	DefaultedString      *string                  `protobuf:"bytes,213,opt,name=defaulted_string,json=defaultedString,def=hello, \"world!\"\n" json:"defaulted_string,omitempty"`
+	DefaultedBytes       []byte                   `protobuf:"bytes,214,opt,name=defaulted_bytes,json=defaultedBytes,def=dead\\336\\255\\276\\357beef" json:"defaulted_bytes,omitempty"`
+	DefaultedChildEnum   *LP2Message_LP2ChildEnum `protobuf:"varint,215,opt,name=defaulted_child_enum,json=defaultedChildEnum,enum=google.golang.org.proto2.LP2Message_LP2ChildEnum,def=10" json:"defaulted_child_enum,omitempty"`
+	DefaultedSiblingEnum *LP2SiblingEnum          `protobuf:"varint,216,opt,name=defaulted_sibling_enum,json=defaultedSiblingEnum,enum=google.golang.org.proto2.LP2SiblingEnum,def=100" json:"defaulted_sibling_enum,omitempty"`
+	// Required fields.
+	RequiredBool           *bool                       `protobuf:"varint,300,req,name=required_bool,json=requiredBool" json:"required_bool,omitempty"`
+	RequiredInt32          *int32                      `protobuf:"varint,301,req,name=required_int32,json=requiredInt32" json:"required_int32,omitempty"`
+	RequiredSint32         *int32                      `protobuf:"zigzag32,302,req,name=required_sint32,json=requiredSint32" json:"required_sint32,omitempty"`
+	RequiredUint32         *uint32                     `protobuf:"varint,303,req,name=required_uint32,json=requiredUint32" json:"required_uint32,omitempty"`
+	RequiredInt64          *int64                      `protobuf:"varint,304,req,name=required_int64,json=requiredInt64" json:"required_int64,omitempty"`
+	RequiredSint64         *int64                      `protobuf:"zigzag64,305,req,name=required_sint64,json=requiredSint64" json:"required_sint64,omitempty"`
+	RequiredUint64         *uint64                     `protobuf:"varint,306,req,name=required_uint64,json=requiredUint64" json:"required_uint64,omitempty"`
+	RequiredFixed32        *uint32                     `protobuf:"fixed32,307,req,name=required_fixed32,json=requiredFixed32" json:"required_fixed32,omitempty"`
+	RequiredSfixed32       *int32                      `protobuf:"fixed32,308,req,name=required_sfixed32,json=requiredSfixed32" json:"required_sfixed32,omitempty"`
+	RequiredFloat          *float32                    `protobuf:"fixed32,309,req,name=required_float,json=requiredFloat" json:"required_float,omitempty"`
+	RequiredFixed64        *uint64                     `protobuf:"fixed64,310,req,name=required_fixed64,json=requiredFixed64" json:"required_fixed64,omitempty"`
+	RequiredSfixed64       *int64                      `protobuf:"fixed64,311,req,name=required_sfixed64,json=requiredSfixed64" json:"required_sfixed64,omitempty"`
+	RequiredDouble         *float64                    `protobuf:"fixed64,312,req,name=required_double,json=requiredDouble" json:"required_double,omitempty"`
+	RequiredString         *string                     `protobuf:"bytes,313,req,name=required_string,json=requiredString" json:"required_string,omitempty"`
+	RequiredBytes          []byte                      `protobuf:"bytes,314,req,name=required_bytes,json=requiredBytes" json:"required_bytes,omitempty"`
+	RequiredChildEnum      *LP2Message_LP2ChildEnum    `protobuf:"varint,315,req,name=required_child_enum,json=requiredChildEnum,enum=google.golang.org.proto2.LP2Message_LP2ChildEnum" json:"required_child_enum,omitempty"`
+	RequiredSiblingEnum    *LP2SiblingEnum             `protobuf:"varint,316,req,name=required_sibling_enum,json=requiredSiblingEnum,enum=google.golang.org.proto2.LP2SiblingEnum" json:"required_sibling_enum,omitempty"`
+	RequiredChildMessage   *LP2Message_LP2ChildMessage `protobuf:"bytes,317,req,name=required_child_message,json=requiredChildMessage" json:"required_child_message,omitempty"`
+	RequiredSiblingMessage *LP2SiblingMessage          `protobuf:"bytes,318,req,name=required_sibling_message,json=requiredSiblingMessage" json:"required_sibling_message,omitempty"`
+	RequiredNamedGroup     *LP2Message_LP2NamedGroup   `protobuf:"bytes,319,req,name=required_named_group,json=requiredNamedGroup" json:"required_named_group,omitempty"`
+	Requiredgroup          *LP2Message_RequiredGroup   `protobuf:"group,320,req,name=RequiredGroup,json=requiredgroup" json:"requiredgroup,omitempty"`
+	// Required default fields.
+	RequiredDefaultedBool        *bool                    `protobuf:"varint,400,req,name=required_defaulted_bool,json=requiredDefaultedBool,def=1" json:"required_defaulted_bool,omitempty"`
+	RequiredDefaultedInt32       *int32                   `protobuf:"varint,401,req,name=required_defaulted_int32,json=requiredDefaultedInt32,def=-12345" json:"required_defaulted_int32,omitempty"`
+	RequiredDefaultedSint32      *int32                   `protobuf:"zigzag32,402,req,name=required_defaulted_sint32,json=requiredDefaultedSint32,def=-3200" json:"required_defaulted_sint32,omitempty"`
+	RequiredDefaultedUint32      *uint32                  `protobuf:"varint,403,req,name=required_defaulted_uint32,json=requiredDefaultedUint32,def=3200" json:"required_defaulted_uint32,omitempty"`
+	RequiredDefaultedInt64       *int64                   `protobuf:"varint,404,req,name=required_defaulted_int64,json=requiredDefaultedInt64,def=-123456789" json:"required_defaulted_int64,omitempty"`
+	RequiredDefaultedSint64      *int64                   `protobuf:"zigzag64,405,req,name=required_defaulted_sint64,json=requiredDefaultedSint64,def=-6400" json:"required_defaulted_sint64,omitempty"`
+	RequiredDefaultedUint64      *uint64                  `protobuf:"varint,406,req,name=required_defaulted_uint64,json=requiredDefaultedUint64,def=6400" json:"required_defaulted_uint64,omitempty"`
+	RequiredDefaultedFixed32     *uint32                  `protobuf:"fixed32,407,req,name=required_defaulted_fixed32,json=requiredDefaultedFixed32,def=320000" json:"required_defaulted_fixed32,omitempty"`
+	RequiredDefaultedSfixed32    *int32                   `protobuf:"fixed32,408,req,name=required_defaulted_sfixed32,json=requiredDefaultedSfixed32,def=-320000" json:"required_defaulted_sfixed32,omitempty"`
+	RequiredDefaultedFloat       *float32                 `protobuf:"fixed32,409,req,name=required_defaulted_float,json=requiredDefaultedFloat,def=3.14159" json:"required_defaulted_float,omitempty"`
+	RequiredDefaultedFixed64     *uint64                  `protobuf:"fixed64,410,req,name=required_defaulted_fixed64,json=requiredDefaultedFixed64,def=640000" json:"required_defaulted_fixed64,omitempty"`
+	RequiredDefaultedSfixed64    *int64                   `protobuf:"fixed64,411,req,name=required_defaulted_sfixed64,json=requiredDefaultedSfixed64,def=-640000" json:"required_defaulted_sfixed64,omitempty"`
+	RequiredDefaultedDouble      *float64                 `protobuf:"fixed64,412,req,name=required_defaulted_double,json=requiredDefaultedDouble,def=3.14159265359" json:"required_defaulted_double,omitempty"`
+	RequiredDefaultedString      *string                  `protobuf:"bytes,413,req,name=required_defaulted_string,json=requiredDefaultedString,def=hello, \"world!\"\n" json:"required_defaulted_string,omitempty"`
+	RequiredDefaultedBytes       []byte                   `protobuf:"bytes,414,req,name=required_defaulted_bytes,json=requiredDefaultedBytes,def=dead\\336\\255\\276\\357beef" json:"required_defaulted_bytes,omitempty"`
+	RequiredDefaultedChildEnum   *LP2Message_LP2ChildEnum `protobuf:"varint,415,req,name=required_defaulted_child_enum,json=requiredDefaultedChildEnum,enum=google.golang.org.proto2.LP2Message_LP2ChildEnum,def=10" json:"required_defaulted_child_enum,omitempty"`
+	RequiredDefaultedSiblingEnum *LP2SiblingEnum          `protobuf:"varint,416,req,name=required_defaulted_sibling_enum,json=requiredDefaultedSiblingEnum,enum=google.golang.org.proto2.LP2SiblingEnum,def=100" json:"required_defaulted_sibling_enum,omitempty"`
+	// Repeated fields.
+	RepeatedBool           []bool                        `protobuf:"varint,500,rep,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
+	RepeatedInt32          []int32                       `protobuf:"varint,501,rep,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
+	RepeatedSint32         []int32                       `protobuf:"zigzag32,502,rep,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
+	RepeatedUint32         []uint32                      `protobuf:"varint,503,rep,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
+	RepeatedInt64          []int64                       `protobuf:"varint,504,rep,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
+	RepeatedSint64         []int64                       `protobuf:"zigzag64,505,rep,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
+	RepeatedUint64         []uint64                      `protobuf:"varint,506,rep,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
+	RepeatedFixed32        []uint32                      `protobuf:"fixed32,507,rep,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
+	RepeatedSfixed32       []int32                       `protobuf:"fixed32,508,rep,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
+	RepeatedFloat          []float32                     `protobuf:"fixed32,509,rep,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
+	RepeatedFixed64        []uint64                      `protobuf:"fixed64,510,rep,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed64       []int64                       `protobuf:"fixed64,511,rep,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
+	RepeatedDouble         []float64                     `protobuf:"fixed64,512,rep,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
+	RepeatedString         []string                      `protobuf:"bytes,513,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                      `protobuf:"bytes,514,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty"`
+	RepeatedChildEnum      []LP2Message_LP2ChildEnum     `protobuf:"varint,515,rep,name=repeated_child_enum,json=repeatedChildEnum,enum=google.golang.org.proto2.LP2Message_LP2ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedSiblingEnum    []LP2SiblingEnum              `protobuf:"varint,516,rep,name=repeated_sibling_enum,json=repeatedSiblingEnum,enum=google.golang.org.proto2.LP2SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedChildMessage   []*LP2Message_LP2ChildMessage `protobuf:"bytes,517,rep,name=repeated_child_message,json=repeatedChildMessage" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingMessage []*LP2SiblingMessage          `protobuf:"bytes,518,rep,name=repeated_sibling_message,json=repeatedSiblingMessage" json:"repeated_sibling_message,omitempty"`
+	RepeatedNamedGroup     []*LP2Message_LP2NamedGroup   `protobuf:"bytes,519,rep,name=repeated_named_group,json=repeatedNamedGroup" json:"repeated_named_group,omitempty"`
+	Repeatedgroup          []*LP2Message_RepeatedGroup   `protobuf:"group,520,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
+	// Repeated packed fields.
+	RepeatedPackedBool     []bool    `protobuf:"varint,600,rep,packed,name=repeated_packed_bool,json=repeatedPackedBool" json:"repeated_packed_bool,omitempty"`
+	RepeatedPackedInt32    []int32   `protobuf:"varint,601,rep,packed,name=repeated_packed_int32,json=repeatedPackedInt32" json:"repeated_packed_int32,omitempty"`
+	RepeatedPackedSint32   []int32   `protobuf:"zigzag32,602,rep,packed,name=repeated_packed_sint32,json=repeatedPackedSint32" json:"repeated_packed_sint32,omitempty"`
+	RepeatedPackedUint32   []uint32  `protobuf:"varint,603,rep,packed,name=repeated_packed_uint32,json=repeatedPackedUint32" json:"repeated_packed_uint32,omitempty"`
+	RepeatedPackedInt64    []int64   `protobuf:"varint,604,rep,packed,name=repeated_packed_int64,json=repeatedPackedInt64" json:"repeated_packed_int64,omitempty"`
+	RepeatedPackedSint64   []int64   `protobuf:"zigzag64,605,rep,packed,name=repeated_packed_sint64,json=repeatedPackedSint64" json:"repeated_packed_sint64,omitempty"`
+	RepeatedPackedUint64   []uint64  `protobuf:"varint,606,rep,packed,name=repeated_packed_uint64,json=repeatedPackedUint64" json:"repeated_packed_uint64,omitempty"`
+	RepeatedPackedFixed32  []uint32  `protobuf:"fixed32,607,rep,packed,name=repeated_packed_fixed32,json=repeatedPackedFixed32" json:"repeated_packed_fixed32,omitempty"`
+	RepeatedPackedSfixed32 []int32   `protobuf:"fixed32,608,rep,packed,name=repeated_packed_sfixed32,json=repeatedPackedSfixed32" json:"repeated_packed_sfixed32,omitempty"`
+	RepeatedPackedFloat    []float32 `protobuf:"fixed32,609,rep,packed,name=repeated_packed_float,json=repeatedPackedFloat" json:"repeated_packed_float,omitempty"`
+	RepeatedPackedFixed64  []uint64  `protobuf:"fixed64,610,rep,packed,name=repeated_packed_fixed64,json=repeatedPackedFixed64" json:"repeated_packed_fixed64,omitempty"`
+	RepeatedPackedSfixed64 []int64   `protobuf:"fixed64,611,rep,packed,name=repeated_packed_sfixed64,json=repeatedPackedSfixed64" json:"repeated_packed_sfixed64,omitempty"`
+	RepeatedPackedDouble   []float64 `protobuf:"fixed64,612,rep,packed,name=repeated_packed_double,json=repeatedPackedDouble" json:"repeated_packed_double,omitempty"`
+	// Repeated non-packed fields.
+	RepeatedNonpackedBool     []bool    `protobuf:"varint,700,rep,name=repeated_nonpacked_bool,json=repeatedNonpackedBool" json:"repeated_nonpacked_bool,omitempty"`
+	RepeatedNonpackedInt32    []int32   `protobuf:"varint,701,rep,name=repeated_nonpacked_int32,json=repeatedNonpackedInt32" json:"repeated_nonpacked_int32,omitempty"`
+	RepeatedNonpackedSint32   []int32   `protobuf:"zigzag32,702,rep,name=repeated_nonpacked_sint32,json=repeatedNonpackedSint32" json:"repeated_nonpacked_sint32,omitempty"`
+	RepeatedNonpackedUint32   []uint32  `protobuf:"varint,703,rep,name=repeated_nonpacked_uint32,json=repeatedNonpackedUint32" json:"repeated_nonpacked_uint32,omitempty"`
+	RepeatedNonpackedInt64    []int64   `protobuf:"varint,704,rep,name=repeated_nonpacked_int64,json=repeatedNonpackedInt64" json:"repeated_nonpacked_int64,omitempty"`
+	RepeatedNonpackedSint64   []int64   `protobuf:"zigzag64,705,rep,name=repeated_nonpacked_sint64,json=repeatedNonpackedSint64" json:"repeated_nonpacked_sint64,omitempty"`
+	RepeatedNonpackedUint64   []uint64  `protobuf:"varint,706,rep,name=repeated_nonpacked_uint64,json=repeatedNonpackedUint64" json:"repeated_nonpacked_uint64,omitempty"`
+	RepeatedNonpackedFixed32  []uint32  `protobuf:"fixed32,707,rep,name=repeated_nonpacked_fixed32,json=repeatedNonpackedFixed32" json:"repeated_nonpacked_fixed32,omitempty"`
+	RepeatedNonpackedSfixed32 []int32   `protobuf:"fixed32,708,rep,name=repeated_nonpacked_sfixed32,json=repeatedNonpackedSfixed32" json:"repeated_nonpacked_sfixed32,omitempty"`
+	RepeatedNonpackedFloat    []float32 `protobuf:"fixed32,709,rep,name=repeated_nonpacked_float,json=repeatedNonpackedFloat" json:"repeated_nonpacked_float,omitempty"`
+	RepeatedNonpackedFixed64  []uint64  `protobuf:"fixed64,710,rep,name=repeated_nonpacked_fixed64,json=repeatedNonpackedFixed64" json:"repeated_nonpacked_fixed64,omitempty"`
+	RepeatedNonpackedSfixed64 []int64   `protobuf:"fixed64,711,rep,name=repeated_nonpacked_sfixed64,json=repeatedNonpackedSfixed64" json:"repeated_nonpacked_sfixed64,omitempty"`
+	RepeatedNonpackedDouble   []float64 `protobuf:"fixed64,712,rep,name=repeated_nonpacked_double,json=repeatedNonpackedDouble" json:"repeated_nonpacked_double,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                        `protobuf:"bytes,800,rep,name=map_bool_bool,json=mapBoolBool" json:"map_bool_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapBoolInt32          map[bool]int32                       `protobuf:"bytes,801,rep,name=map_bool_int32,json=mapBoolInt32" json:"map_bool_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapBoolSint32         map[bool]int32                       `protobuf:"bytes,802,rep,name=map_bool_sint32,json=mapBoolSint32" json:"map_bool_sint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
+	MapBoolUint32         map[bool]uint32                      `protobuf:"bytes,803,rep,name=map_bool_uint32,json=mapBoolUint32" json:"map_bool_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapBoolInt64          map[bool]int64                       `protobuf:"bytes,804,rep,name=map_bool_int64,json=mapBoolInt64" json:"map_bool_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapBoolSint64         map[bool]int64                       `protobuf:"bytes,805,rep,name=map_bool_sint64,json=mapBoolSint64" json:"map_bool_sint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
+	MapBoolUint64         map[bool]uint64                      `protobuf:"bytes,806,rep,name=map_bool_uint64,json=mapBoolUint64" json:"map_bool_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapBoolFixed32        map[bool]uint32                      `protobuf:"bytes,807,rep,name=map_bool_fixed32,json=mapBoolFixed32" json:"map_bool_fixed32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapBoolSfixed32       map[bool]int32                       `protobuf:"bytes,808,rep,name=map_bool_sfixed32,json=mapBoolSfixed32" json:"map_bool_sfixed32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapBoolFloat          map[bool]float32                     `protobuf:"bytes,809,rep,name=map_bool_float,json=mapBoolFloat" json:"map_bool_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
+	MapBoolFixed64        map[bool]uint64                      `protobuf:"bytes,810,rep,name=map_bool_fixed64,json=mapBoolFixed64" json:"map_bool_fixed64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapBoolSfixed64       map[bool]int64                       `protobuf:"bytes,811,rep,name=map_bool_sfixed64,json=mapBoolSfixed64" json:"map_bool_sfixed64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapBoolDouble         map[bool]float64                     `protobuf:"bytes,812,rep,name=map_bool_double,json=mapBoolDouble" json:"map_bool_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
+	MapBoolString         map[bool]string                      `protobuf:"bytes,813,rep,name=map_bool_string,json=mapBoolString" json:"map_bool_string,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapBoolBytes          map[bool][]byte                      `protobuf:"bytes,814,rep,name=map_bool_bytes,json=mapBoolBytes" json:"map_bool_bytes,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapBoolEnum           map[bool]LP2MapEnum                  `protobuf:"bytes,815,rep,name=map_bool_enum,json=mapBoolEnum" json:"map_bool_enum,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=google.golang.org.proto2.LP2MapEnum"`
+	MapBoolChildMessage   map[bool]*LP2Message_LP2ChildMessage `protobuf:"bytes,816,rep,name=map_bool_child_message,json=mapBoolChildMessage" json:"map_bool_child_message,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapBoolSiblingMessage map[bool]*LP2SiblingMessage          `protobuf:"bytes,817,rep,name=map_bool_sibling_message,json=mapBoolSiblingMessage" json:"map_bool_sibling_message,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapBoolNamedGroup     map[bool]*LP2Message_LP2NamedGroup   `protobuf:"bytes,818,rep,name=map_bool_named_group,json=mapBoolNamedGroup" json:"map_bool_named_group,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
+	MapInt32Bool          map[int32]bool                       `protobuf:"bytes,819,rep,name=map_int32_bool,json=mapInt32Bool" json:"map_int32_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapSint32Bool         map[int32]bool                       `protobuf:"bytes,820,rep,name=map_sint32_bool,json=mapSint32Bool" json:"map_sint32_bool,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapUint32Bool         map[uint32]bool                      `protobuf:"bytes,821,rep,name=map_uint32_bool,json=mapUint32Bool" json:"map_uint32_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapInt64Bool          map[int64]bool                       `protobuf:"bytes,822,rep,name=map_int64_bool,json=mapInt64Bool" json:"map_int64_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapSint64Bool         map[int64]bool                       `protobuf:"bytes,823,rep,name=map_sint64_bool,json=mapSint64Bool" json:"map_sint64_bool,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapUint64Bool         map[uint64]bool                      `protobuf:"bytes,824,rep,name=map_uint64_bool,json=mapUint64Bool" json:"map_uint64_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapFixed32Bool        map[uint32]bool                      `protobuf:"bytes,825,rep,name=map_fixed32_bool,json=mapFixed32Bool" json:"map_fixed32_bool,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	MapStringBool         map[string]bool                      `protobuf:"bytes,826,rep,name=map_string_bool,json=mapStringBool" json:"map_string_bool,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
+	// Oneof fields.
+	OneofUnion isLP2Message_OneofUnion `protobuf_oneof:"oneof_union"`
+	// Oneof default fields.
+	OneofDefaultedUnion          isLP2Message_OneofDefaultedUnion `protobuf_oneof:"oneof_defaulted_union"`
+	XXX_NoUnkeyedLiteral         struct{}                         `json:"-"`
+	proto.XXX_InternalExtensions `json:"-"`
+	XXX_unrecognized             []byte `json:"-"`
+	XXX_sizecache                int32  `json:"-"`
+}
+
+func (*LP2Message) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1}
+}
+
+var extRange_LP2Message = []proto.ExtensionRange{
+	{Start: 10000, End: 536870911},
+}
+
+func (*LP2Message) ExtensionRangeArray() []proto.ExtensionRange {
+	return extRange_LP2Message
+}
+
+type isLP2Message_OneofUnion interface {
+	isLP2Message_OneofUnion()
+}
+type isLP2Message_OneofDefaultedUnion interface {
+	isLP2Message_OneofDefaultedUnion()
+}
+
+type LP2Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,900,opt,name=oneof_bool,json=oneofBool,oneof"`
+}
+type LP2Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,901,opt,name=oneof_int32,json=oneofInt32,oneof"`
+}
+type LP2Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,902,opt,name=oneof_sint32,json=oneofSint32,oneof"`
+}
+type LP2Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,903,opt,name=oneof_uint32,json=oneofUint32,oneof"`
+}
+type LP2Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,904,opt,name=oneof_int64,json=oneofInt64,oneof"`
+}
+type LP2Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,905,opt,name=oneof_sint64,json=oneofSint64,oneof"`
+}
+type LP2Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,906,opt,name=oneof_uint64,json=oneofUint64,oneof"`
+}
+type LP2Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,907,opt,name=oneof_fixed32,json=oneofFixed32,oneof"`
+}
+type LP2Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,908,opt,name=oneof_sfixed32,json=oneofSfixed32,oneof"`
+}
+type LP2Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,909,opt,name=oneof_float,json=oneofFloat,oneof"`
+}
+type LP2Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,910,opt,name=oneof_fixed64,json=oneofFixed64,oneof"`
+}
+type LP2Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,911,opt,name=oneof_sfixed64,json=oneofSfixed64,oneof"`
+}
+type LP2Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,912,opt,name=oneof_double,json=oneofDouble,oneof"`
+}
+type LP2Message_OneofString struct {
+	OneofString string `protobuf:"bytes,913,opt,name=oneof_string,json=oneofString,oneof"`
+}
+type LP2Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,914,opt,name=oneof_bytes,json=oneofBytes,oneof"`
+}
+type LP2Message_OneofChildEnum struct {
+	OneofChildEnum LP2Message_LP2ChildEnum `protobuf:"varint,915,opt,name=oneof_child_enum,json=oneofChildEnum,enum=google.golang.org.proto2.LP2Message_LP2ChildEnum,oneof"`
+}
+type LP2Message_OneofSiblingEnum struct {
+	OneofSiblingEnum LP2SiblingEnum `protobuf:"varint,916,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,enum=google.golang.org.proto2.LP2SiblingEnum,oneof"`
+}
+type LP2Message_OneofChildMessage struct {
+	OneofChildMessage *LP2Message_LP2ChildMessage `protobuf:"bytes,917,opt,name=oneof_child_message,json=oneofChildMessage,oneof"`
+}
+type LP2Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *LP2SiblingMessage `protobuf:"bytes,918,opt,name=oneof_sibling_message,json=oneofSiblingMessage,oneof"`
+}
+type LP2Message_OneofNamedGroup struct {
+	OneofNamedGroup *LP2Message_LP2NamedGroup `protobuf:"bytes,919,opt,name=oneof_named_group,json=oneofNamedGroup,oneof"`
+}
+type LP2Message_Oneofgroup struct {
+	Oneofgroup *LP2Message_OneofGroup `protobuf:"group,920,opt,name=OneofGroup,json=oneofgroup,oneof"`
+}
+type LP2Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,921,opt,name=oneof_string1,json=oneofString1,oneof"`
+}
+type LP2Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,922,opt,name=oneof_string2,json=oneofString2,oneof"`
+}
+type LP2Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,923,opt,name=oneof_string3,json=oneofString3,oneof"`
+}
+type LP2Message_OneofDefaultedBool struct {
+	OneofDefaultedBool bool `protobuf:"varint,1000,opt,name=oneof_defaulted_bool,json=oneofDefaultedBool,oneof,def=1"`
+}
+type LP2Message_OneofDefaultedInt32 struct {
+	OneofDefaultedInt32 int32 `protobuf:"varint,1001,opt,name=oneof_defaulted_int32,json=oneofDefaultedInt32,oneof,def=-12345"`
+}
+type LP2Message_OneofDefaultedSint32 struct {
+	OneofDefaultedSint32 int32 `protobuf:"zigzag32,1002,opt,name=oneof_defaulted_sint32,json=oneofDefaultedSint32,oneof,def=-3200"`
+}
+type LP2Message_OneofDefaultedUint32 struct {
+	OneofDefaultedUint32 uint32 `protobuf:"varint,1003,opt,name=oneof_defaulted_uint32,json=oneofDefaultedUint32,oneof,def=3200"`
+}
+type LP2Message_OneofDefaultedInt64 struct {
+	OneofDefaultedInt64 int64 `protobuf:"varint,1004,opt,name=oneof_defaulted_int64,json=oneofDefaultedInt64,oneof,def=-123456789"`
+}
+type LP2Message_OneofDefaultedSint64 struct {
+	OneofDefaultedSint64 int64 `protobuf:"zigzag64,1005,opt,name=oneof_defaulted_sint64,json=oneofDefaultedSint64,oneof,def=-6400"`
+}
+type LP2Message_OneofDefaultedUint64 struct {
+	OneofDefaultedUint64 uint64 `protobuf:"varint,1006,opt,name=oneof_defaulted_uint64,json=oneofDefaultedUint64,oneof,def=6400"`
+}
+type LP2Message_OneofDefaultedFixed32 struct {
+	OneofDefaultedFixed32 uint32 `protobuf:"fixed32,1007,opt,name=oneof_defaulted_fixed32,json=oneofDefaultedFixed32,oneof,def=320000"`
+}
+type LP2Message_OneofDefaultedSfixed32 struct {
+	OneofDefaultedSfixed32 int32 `protobuf:"fixed32,1008,opt,name=oneof_defaulted_sfixed32,json=oneofDefaultedSfixed32,oneof,def=-320000"`
+}
+type LP2Message_OneofDefaultedFloat struct {
+	OneofDefaultedFloat float32 `protobuf:"fixed32,1009,opt,name=oneof_defaulted_float,json=oneofDefaultedFloat,oneof,def=3.14159"`
+}
+type LP2Message_OneofDefaultedFixed64 struct {
+	OneofDefaultedFixed64 uint64 `protobuf:"fixed64,1010,opt,name=oneof_defaulted_fixed64,json=oneofDefaultedFixed64,oneof,def=640000"`
+}
+type LP2Message_OneofDefaultedSfixed64 struct {
+	OneofDefaultedSfixed64 int64 `protobuf:"fixed64,1011,opt,name=oneof_defaulted_sfixed64,json=oneofDefaultedSfixed64,oneof,def=-640000"`
+}
+type LP2Message_OneofDefaultedDouble struct {
+	OneofDefaultedDouble float64 `protobuf:"fixed64,1012,opt,name=oneof_defaulted_double,json=oneofDefaultedDouble,oneof,def=3.14159265359"`
+}
+type LP2Message_OneofDefaultedString struct {
+	OneofDefaultedString string `protobuf:"bytes,1013,opt,name=oneof_defaulted_string,json=oneofDefaultedString,oneof,def=hello, \"world!\"\n"`
+}
+type LP2Message_OneofDefaultedBytes struct {
+	OneofDefaultedBytes []byte `protobuf:"bytes,1014,opt,name=oneof_defaulted_bytes,json=oneofDefaultedBytes,oneof,def=dead\\336\\255\\276\\357beef"`
+}
+type LP2Message_OneofDefaultedChildEnum struct {
+	OneofDefaultedChildEnum LP2Message_LP2ChildEnum `protobuf:"varint,1015,opt,name=oneof_defaulted_child_enum,json=oneofDefaultedChildEnum,enum=google.golang.org.proto2.LP2Message_LP2ChildEnum,oneof,def=10"`
+}
+type LP2Message_OneofDefaultedSiblingEnum struct {
+	OneofDefaultedSiblingEnum LP2SiblingEnum `protobuf:"varint,1016,opt,name=oneof_defaulted_sibling_enum,json=oneofDefaultedSiblingEnum,enum=google.golang.org.proto2.LP2SiblingEnum,oneof,def=100"`
+}
+
+func (*LP2Message_OneofBool) isLP2Message_OneofUnion()                          {}
+func (*LP2Message_OneofInt32) isLP2Message_OneofUnion()                         {}
+func (*LP2Message_OneofSint32) isLP2Message_OneofUnion()                        {}
+func (*LP2Message_OneofUint32) isLP2Message_OneofUnion()                        {}
+func (*LP2Message_OneofInt64) isLP2Message_OneofUnion()                         {}
+func (*LP2Message_OneofSint64) isLP2Message_OneofUnion()                        {}
+func (*LP2Message_OneofUint64) isLP2Message_OneofUnion()                        {}
+func (*LP2Message_OneofFixed32) isLP2Message_OneofUnion()                       {}
+func (*LP2Message_OneofSfixed32) isLP2Message_OneofUnion()                      {}
+func (*LP2Message_OneofFloat) isLP2Message_OneofUnion()                         {}
+func (*LP2Message_OneofFixed64) isLP2Message_OneofUnion()                       {}
+func (*LP2Message_OneofSfixed64) isLP2Message_OneofUnion()                      {}
+func (*LP2Message_OneofDouble) isLP2Message_OneofUnion()                        {}
+func (*LP2Message_OneofString) isLP2Message_OneofUnion()                        {}
+func (*LP2Message_OneofBytes) isLP2Message_OneofUnion()                         {}
+func (*LP2Message_OneofChildEnum) isLP2Message_OneofUnion()                     {}
+func (*LP2Message_OneofSiblingEnum) isLP2Message_OneofUnion()                   {}
+func (*LP2Message_OneofChildMessage) isLP2Message_OneofUnion()                  {}
+func (*LP2Message_OneofSiblingMessage) isLP2Message_OneofUnion()                {}
+func (*LP2Message_OneofNamedGroup) isLP2Message_OneofUnion()                    {}
+func (*LP2Message_Oneofgroup) isLP2Message_OneofUnion()                         {}
+func (*LP2Message_OneofString1) isLP2Message_OneofUnion()                       {}
+func (*LP2Message_OneofString2) isLP2Message_OneofUnion()                       {}
+func (*LP2Message_OneofString3) isLP2Message_OneofUnion()                       {}
+func (*LP2Message_OneofDefaultedBool) isLP2Message_OneofDefaultedUnion()        {}
+func (*LP2Message_OneofDefaultedInt32) isLP2Message_OneofDefaultedUnion()       {}
+func (*LP2Message_OneofDefaultedSint32) isLP2Message_OneofDefaultedUnion()      {}
+func (*LP2Message_OneofDefaultedUint32) isLP2Message_OneofDefaultedUnion()      {}
+func (*LP2Message_OneofDefaultedInt64) isLP2Message_OneofDefaultedUnion()       {}
+func (*LP2Message_OneofDefaultedSint64) isLP2Message_OneofDefaultedUnion()      {}
+func (*LP2Message_OneofDefaultedUint64) isLP2Message_OneofDefaultedUnion()      {}
+func (*LP2Message_OneofDefaultedFixed32) isLP2Message_OneofDefaultedUnion()     {}
+func (*LP2Message_OneofDefaultedSfixed32) isLP2Message_OneofDefaultedUnion()    {}
+func (*LP2Message_OneofDefaultedFloat) isLP2Message_OneofDefaultedUnion()       {}
+func (*LP2Message_OneofDefaultedFixed64) isLP2Message_OneofDefaultedUnion()     {}
+func (*LP2Message_OneofDefaultedSfixed64) isLP2Message_OneofDefaultedUnion()    {}
+func (*LP2Message_OneofDefaultedDouble) isLP2Message_OneofDefaultedUnion()      {}
+func (*LP2Message_OneofDefaultedString) isLP2Message_OneofDefaultedUnion()      {}
+func (*LP2Message_OneofDefaultedBytes) isLP2Message_OneofDefaultedUnion()       {}
+func (*LP2Message_OneofDefaultedChildEnum) isLP2Message_OneofDefaultedUnion()   {}
+func (*LP2Message_OneofDefaultedSiblingEnum) isLP2Message_OneofDefaultedUnion() {}
+
+func (*LP2Message) XXX_OneofFuncs() (func(proto.Message, *proto.Buffer) error, func(proto.Message, int, int, *proto.Buffer) (bool, error), func(proto.Message) int, []interface{}) {
+	return nil, nil, nil, []interface{}{
+		(*LP2Message_OneofBool)(nil),
+		(*LP2Message_OneofInt32)(nil),
+		(*LP2Message_OneofSint32)(nil),
+		(*LP2Message_OneofUint32)(nil),
+		(*LP2Message_OneofInt64)(nil),
+		(*LP2Message_OneofSint64)(nil),
+		(*LP2Message_OneofUint64)(nil),
+		(*LP2Message_OneofFixed32)(nil),
+		(*LP2Message_OneofSfixed32)(nil),
+		(*LP2Message_OneofFloat)(nil),
+		(*LP2Message_OneofFixed64)(nil),
+		(*LP2Message_OneofSfixed64)(nil),
+		(*LP2Message_OneofDouble)(nil),
+		(*LP2Message_OneofString)(nil),
+		(*LP2Message_OneofBytes)(nil),
+		(*LP2Message_OneofChildEnum)(nil),
+		(*LP2Message_OneofSiblingEnum)(nil),
+		(*LP2Message_OneofChildMessage)(nil),
+		(*LP2Message_OneofSiblingMessage)(nil),
+		(*LP2Message_OneofNamedGroup)(nil),
+		(*LP2Message_Oneofgroup)(nil),
+		(*LP2Message_OneofString1)(nil),
+		(*LP2Message_OneofString2)(nil),
+		(*LP2Message_OneofString3)(nil),
+		(*LP2Message_OneofDefaultedBool)(nil),
+		(*LP2Message_OneofDefaultedInt32)(nil),
+		(*LP2Message_OneofDefaultedSint32)(nil),
+		(*LP2Message_OneofDefaultedUint32)(nil),
+		(*LP2Message_OneofDefaultedInt64)(nil),
+		(*LP2Message_OneofDefaultedSint64)(nil),
+		(*LP2Message_OneofDefaultedUint64)(nil),
+		(*LP2Message_OneofDefaultedFixed32)(nil),
+		(*LP2Message_OneofDefaultedSfixed32)(nil),
+		(*LP2Message_OneofDefaultedFloat)(nil),
+		(*LP2Message_OneofDefaultedFixed64)(nil),
+		(*LP2Message_OneofDefaultedSfixed64)(nil),
+		(*LP2Message_OneofDefaultedDouble)(nil),
+		(*LP2Message_OneofDefaultedString)(nil),
+		(*LP2Message_OneofDefaultedBytes)(nil),
+		(*LP2Message_OneofDefaultedChildEnum)(nil),
+		(*LP2Message_OneofDefaultedSiblingEnum)(nil),
+	}
+}
+
+type LP2Message_LP2ChildMessage struct {
+	F1                   *string  `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   *string  `protobuf:"bytes,2,req,name=f2" json:"f2,omitempty"`
+	F3                   []string `protobuf:"bytes,3,rep,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP2Message_LP2ChildMessage) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1, 0}
+}
+
+type LP2Message_LP2NamedGroup struct {
+	F1                   *string  `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   *string  `protobuf:"bytes,2,req,name=f2" json:"f2,omitempty"`
+	F3                   []string `protobuf:"bytes,3,rep,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP2Message_LP2NamedGroup) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1, 1}
+}
+
+type LP2Message_OptionalGroup struct {
+	F1                   *string  `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   *string  `protobuf:"bytes,2,req,name=f2" json:"f2,omitempty"`
+	F3                   []string `protobuf:"bytes,3,rep,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP2Message_OptionalGroup) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1, 2}
+}
+
+type LP2Message_RequiredGroup struct {
+	F1                   *string  `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   *string  `protobuf:"bytes,2,req,name=f2" json:"f2,omitempty"`
+	F3                   []string `protobuf:"bytes,3,rep,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP2Message_RequiredGroup) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1, 3}
+}
+
+type LP2Message_RepeatedGroup struct {
+	F1                   *string  `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   *string  `protobuf:"bytes,2,req,name=f2" json:"f2,omitempty"`
+	F3                   []string `protobuf:"bytes,3,rep,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP2Message_RepeatedGroup) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1, 4}
+}
+
+type LP2Message_OneofGroup struct {
+	F1                   *string  `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
+	F2                   *string  `protobuf:"bytes,2,req,name=f2" json:"f2,omitempty"`
+	F3                   []string `protobuf:"bytes,3,rep,name=f3" json:"f3,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP2Message_OneofGroup) Descriptor() ([]byte, []int) {
+	return LP2FileDescriptor, []int{1, 32}
+}
+
+var LP2FileDescriptor = []byte{
+	// 3741 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x5b, 0x67, 0x74, 0x1b, 0xc7,
+	0xb5, 0xc6, 0x02, 0x04, 0x97, 0x1a, 0x11, 0x24, 0xb0, 0xa4, 0xa8, 0x11, 0x9f, 0xdf, 0x7b, 0x88,
+	0xe2, 0x38, 0x88, 0x6c, 0x29, 0x22, 0x38, 0x1c, 0x59, 0xb0, 0x65, 0x85, 0x94, 0xe5, 0xc0, 0x3e,
+	0xb2, 0xa4, 0xb3, 0x8a, 0x92, 0xd8, 0x47, 0x8e, 0x42, 0x99, 0x20, 0x4d, 0x0b, 0x24, 0x68, 0x92,
+	0xb0, 0xa5, 0x73, 0xfc, 0x43, 0x49, 0xdc, 0xd2, 0xdd, 0x6b, 0x8a, 0xd3, 0x9b, 0x7b, 0xb7, 0xe3,
+	0x96, 0xee, 0xf4, 0x9e, 0x38, 0xbd, 0xfe, 0x48, 0xaf, 0x6e, 0xe9, 0x39, 0x33, 0x77, 0x66, 0x67,
+	0x66, 0x77, 0x96, 0x04, 0xd6, 0x3f, 0x7c, 0x4c, 0x0c, 0xee, 0xfd, 0xbe, 0xb9, 0x77, 0xe7, 0x7e,
+	0x73, 0x77, 0x30, 0x42, 0x85, 0xc5, 0xda, 0xc2, 0xe2, 0xfe, 0xb9, 0xf9, 0xc6, 0x62, 0xa3, 0xbc,
+	0x81, 0xff, 0xcf, 0xc3, 0x53, 0x8d, 0xc6, 0x54, 0xbd, 0xb6, 0x61, 0xaa, 0x51, 0x1f, 0x9f, 0x9d,
+	0xda, 0xd0, 0x98, 0x9f, 0x82, 0x2f, 0xca, 0x6b, 0xb7, 0xa1, 0xc2, 0x8e, 0xdd, 0xe5, 0x3d, 0xd3,
+	0x07, 0xea, 0xd3, 0xb3, 0x53, 0xa7, 0xd7, 0x16, 0x16, 0xc6, 0xa7, 0x6a, 0x5e, 0x0f, 0x4a, 0x4f,
+	0x0e, 0x61, 0xa7, 0xe8, 0x94, 0x56, 0xf8, 0xe9, 0xc9, 0x21, 0xfe, 0xb9, 0x8c, 0xd3, 0xc5, 0x34,
+	0xff, 0x5c, 0xe6, 0x9f, 0x87, 0x71, 0xa6, 0x98, 0xe1, 0x9f, 0x87, 0xd7, 0x3e, 0x7c, 0x08, 0xa1,
+	0x1d, 0xbb, 0xcb, 0xd2, 0xfd, 0xd5, 0x28, 0x57, 0x9f, 0x2b, 0xcf, 0x8e, 0xcf, 0xd4, 0x26, 0xa6,
+	0xe6, 0x1b, 0xcd, 0x39, 0x8e, 0x84, 0xca, 0xe5, 0x0d, 0x71, 0xb3, 0xd8, 0xa0, 0x9c, 0xd9, 0x9f,
+	0x3b, 0x99, 0xe7, 0xcb, 0x99, 0xa7, 0x6f, 0x02, 0x79, 0x2f, 0x44, 0xb9, 0xc6, 0xdc, 0xe2, 0x74,
+	0x63, 0x76, 0xbc, 0xbe, 0xff, 0x40, 0xa3, 0x51, 0xc7, 0x13, 0x45, 0xa7, 0xd4, 0xe5, 0x77, 0xcb,
+	0xc1, 0xb1, 0x46, 0xa3, 0xee, 0xbd, 0x08, 0xf5, 0x04, 0x46, 0xd3, 0xb3, 0x8b, 0xc3, 0x65, 0x5c,
+	0x2b, 0x3a, 0xa5, 0xac, 0x1f, 0xb8, 0x9e, 0xca, 0x06, 0xbd, 0x17, 0xa3, 0xde, 0xc0, 0x6c, 0x01,
+	0xec, 0x26, 0x8b, 0x4e, 0xa9, 0xe0, 0x07, 0xde, 0x7b, 0xa6, 0x23, 0x86, 0x4d, 0x30, 0x9c, 0x2a,
+	0x3a, 0xa5, 0x9c, 0x32, 0xdc, 0x0b, 0x86, 0x21, 0x62, 0x4a, 0xf0, 0x39, 0x45, 0xa7, 0x94, 0x31,
+	0x88, 0x29, 0x89, 0x10, 0x53, 0x82, 0xa7, 0x8b, 0x4e, 0xc9, 0x33, 0x89, 0x43, 0x86, 0x4d, 0x30,
+	0x3c, 0xb7, 0xe8, 0x94, 0x3a, 0x4c, 0x62, 0x4a, 0xbc, 0x97, 0xa0, 0x7c, 0x60, 0x38, 0x39, 0x7d,
+	0xa8, 0x36, 0x31, 0x5c, 0xc6, 0x07, 0x8b, 0x4e, 0xc9, 0xf5, 0x03, 0x80, 0x53, 0x60, 0xd8, 0x3b,
+	0x16, 0x15, 0x14, 0xb9, 0xb4, 0xad, 0x17, 0x9d, 0x52, 0xaf, 0x1f, 0x60, 0xec, 0x11, 0xe3, 0x46,
+	0x40, 0x93, 0xf5, 0xc6, 0xf8, 0x22, 0x9e, 0x29, 0x3a, 0xa5, 0xb4, 0x0a, 0xe8, 0x14, 0x36, 0x18,
+	0xa5, 0xa7, 0x04, 0xcf, 0x16, 0x9d, 0x52, 0x67, 0x88, 0x9e, 0x12, 0x0b, 0x3d, 0x25, 0xb8, 0x51,
+	0x74, 0x4a, 0xf9, 0x30, 0x7d, 0x28, 0xfe, 0x89, 0x46, 0xf3, 0x40, 0xbd, 0x86, 0xe7, 0x8a, 0x4e,
+	0xc9, 0x51, 0xf1, 0x9f, 0xcc, 0x47, 0xcd, 0x8c, 0x2e, 0xce, 0x4f, 0xcf, 0x4e, 0xe1, 0xf3, 0xf8,
+	0xe2, 0x55, 0x19, 0xe5, 0xa3, 0x46, 0x40, 0x07, 0x0e, 0x2f, 0xd6, 0x16, 0xf0, 0x7c, 0xd1, 0x29,
+	0x75, 0xab, 0x80, 0xc6, 0xd8, 0xa0, 0x37, 0x8e, 0xfa, 0x02, 0xb3, 0xb3, 0xcf, 0x99, 0xae, 0x4f,
+	0xec, 0xaf, 0xcd, 0x36, 0x67, 0xf0, 0x42, 0xd1, 0x29, 0xf5, 0x94, 0x87, 0x5a, 0x5d, 0xc6, 0xdb,
+	0x98, 0xe7, 0xf6, 0xd9, 0xe6, 0x8c, 0x1f, 0xc4, 0x1c, 0x0c, 0x79, 0xfb, 0xd0, 0x2a, 0x6d, 0x11,
+	0xf0, 0xea, 0x03, 0x92, 0x45, 0x4e, 0x52, 0x5a, 0x92, 0x44, 0x94, 0x2b, 0xc7, 0xee, 0x53, 0x8b,
+	0x26, 0x18, 0xf4, 0xce, 0x45, 0x03, 0xa1, 0x00, 0x66, 0x60, 0x5e, 0xb8, 0x59, 0x74, 0x4a, 0x2b,
+	0xcb, 0xa4, 0xad, 0x18, 0xc4, 0x67, 0xbf, 0xdf, 0x08, 0x43, 0x56, 0x7b, 0x0d, 0xe1, 0x48, 0x24,
+	0x92, 0xed, 0x7c, 0xce, 0x76, 0x6c, 0x2b, 0xc1, 0x48, 0x92, 0x81, 0x50, 0x3c, 0x92, 0x66, 0x02,
+	0x05, 0xf4, 0xfb, 0xb9, 0x22, 0xec, 0x07, 0x6d, 0xb9, 0x80, 0x53, 0x24, 0xd1, 0x16, 0x4f, 0xe2,
+	0xa9, 0x31, 0x26, 0x5d, 0x72, 0x14, 0xe0, 0x0f, 0xb5, 0x21, 0x5d, 0xbb, 0x84, 0xa7, 0x90, 0x2e,
+	0x03, 0xc8, 0x3b, 0x0e, 0xf5, 0x4c, 0xd4, 0x26, 0xc7, 0x9b, 0xf5, 0xc5, 0xda, 0x04, 0x68, 0xd7,
+	0x13, 0x4c, 0x16, 0xbb, 0x2a, 0x1d, 0x8b, 0xf3, 0xcd, 0x9a, 0x9f, 0x0b, 0xbe, 0xe4, 0x1a, 0xb6,
+	0x11, 0xf5, 0x2a, 0x6b, 0xd0, 0x9c, 0xcf, 0x33, 0xf3, 0x6c, 0xa5, 0x73, 0xfd, 0x50, 0x79, 0x98,
+	0x8c, 0xf8, 0x0a, 0x0d, 0xe4, 0x6c, 0x08, 0xe5, 0x95, 0x87, 0xd0, 0xb3, 0x2f, 0x30, 0x97, 0x42,
+	0x25, 0xbb, 0x7e, 0xb8, 0xbc, 0x71, 0xa3, 0xaf, 0x10, 0x85, 0xb0, 0x6d, 0xd4, 0x5d, 0x84, 0xb2,
+	0x7d, 0x91, 0xb9, 0xe4, 0x2a, 0x1d, 0x21, 0x0f, 0xa1, 0x70, 0x24, 0x34, 0x2d, 0x4a, 0xf0, 0x97,
+	0x98, 0x43, 0xa6, 0x82, 0x60, 0x5a, 0x74, 0xd3, 0xf1, 0x9b, 0xcd, 0xa9, 0x51, 0x12, 0x9d, 0x1a,
+	0x25, 0xf8, 0xcb, 0xcc, 0xcd, 0xab, 0x64, 0xd7, 0x53, 0x12, 0x99, 0x1a, 0x25, 0xd1, 0xa9, 0x51,
+	0x82, 0xbf, 0xc2, 0x5c, 0x3a, 0x2a, 0x1d, 0x21, 0x0f, 0xa1, 0x81, 0x04, 0x15, 0x94, 0x87, 0x14,
+	0xb6, 0xaf, 0x32, 0x17, 0xb7, 0xd2, 0xc9, 0xa2, 0xd9, 0xb8, 0xd1, 0x57, 0x98, 0x52, 0x0e, 0x37,
+	0x21, 0x4f, 0x9b, 0x9a, 0x74, 0xfb, 0x1a, 0x73, 0xeb, 0xad, 0xb8, 0xeb, 0x85, 0x9f, 0x42, 0x0e,
+	0xa4, 0x71, 0x48, 0xcf, 0x04, 0x68, 0xe3, 0xd7, 0x99, 0x57, 0xba, 0xe2, 0x0e, 0x6f, 0x18, 0x22,
+	0x43, 0x23, 0x7a, 0x1a, 0x40, 0x26, 0xa3, 0x33, 0xa4, 0x04, 0x7f, 0x83, 0x39, 0x75, 0x56, 0x3a,
+	0x59, 0x50, 0xd1, 0x19, 0x52, 0x62, 0x9b, 0x21, 0x25, 0xf8, 0x9b, 0xcc, 0x2d, 0x5f, 0x71, 0xd7,
+	0x0b, 0xbf, 0xf0, 0x0c, 0x29, 0xf1, 0x36, 0xeb, 0x29, 0x14, 0xf2, 0xf9, 0x2d, 0xe6, 0xe6, 0x54,
+	0x72, 0x62, 0x8a, 0x65, 0x3a, 0x32, 0x3c, 0xb2, 0x59, 0xcb, 0xa5, 0xd0, 0xd3, 0x13, 0x8d, 0x07,
+	0x06, 0x82, 0xfa, 0x6d, 0xde, 0x0e, 0x54, 0xf2, 0xe7, 0xd4, 0xea, 0xf5, 0xc6, 0x71, 0xc5, 0xb5,
+	0x17, 0x34, 0xe6, 0xeb, 0x13, 0x2f, 0x58, 0x8b, 0xf4, 0x67, 0x07, 0x22, 0x3b, 0xa6, 0xa7, 0x06,
+	0x54, 0xf6, 0x3b, 0xcc, 0xb9, 0xbb, 0x82, 0x27, 0x6a, 0xe3, 0x13, 0xfb, 0x86, 0x87, 0xe9, 0xbe,
+	0xf2, 0xc8, 0xc8, 0xbe, 0xf2, 0x26, 0xba, 0x6f, 0x78, 0x64, 0xd3, 0x81, 0x5a, 0x6d, 0x52, 0xcb,
+	0x15, 0x28, 0xf0, 0x41, 0xd4, 0xaf, 0x30, 0x34, 0x09, 0xfe, 0xae, 0x93, 0x50, 0x83, 0x2b, 0xd9,
+	0xd1, 0x1d, 0xbb, 0xab, 0xa3, 0xbe, 0x4a, 0xa6, 0xd2, 0xe2, 0x49, 0x34, 0xa0, 0xaf, 0x4f, 0x4d,
+	0x8c, 0x9f, 0x74, 0xda, 0x53, 0x63, 0xc9, 0xd2, 0xaf, 0xad, 0x67, 0xa5, 0xca, 0x47, 0xa3, 0xdc,
+	0x7c, 0xed, 0xbc, 0xe6, 0xf4, 0xbc, 0x54, 0x80, 0x5b, 0x58, 0x4b, 0xd5, 0xe5, 0x77, 0xcb, 0x51,
+	0x5e, 0xfa, 0xc7, 0xa0, 0x9e, 0xc0, 0x0a, 0x6a, 0xf2, 0x56, 0x66, 0x96, 0xf5, 0x03, 0x67, 0x28,
+	0xf8, 0x12, 0xea, 0x0d, 0xec, 0x44, 0xbd, 0xdf, 0xc6, 0x0c, 0x0b, 0x7e, 0xe0, 0x2f, 0xea, 0x5c,
+	0xb7, 0x14, 0x65, 0x7e, 0x3b, 0xb3, 0xcc, 0x29, 0x4b, 0x51, 0xdf, 0x21, 0x6e, 0x4a, 0xf0, 0x1d,
+	0xcc, 0x30, 0x63, 0x70, 0x53, 0x12, 0xe1, 0xa6, 0x04, 0xdf, 0xc9, 0x0c, 0x3d, 0x93, 0x3b, 0x64,
+	0x29, 0xea, 0xf8, 0x2e, 0x66, 0xd9, 0x61, 0x72, 0x53, 0xe2, 0xad, 0x43, 0xf9, 0xc0, 0x52, 0x16,
+	0xe2, 0xdd, 0xcc, 0xd4, 0xf5, 0x03, 0x08, 0x59, 0xb6, 0xc7, 0xa1, 0x82, 0xe2, 0x97, 0xc6, 0xf7,
+	0x30, 0xe3, 0x5e, 0x3f, 0x40, 0x09, 0x6a, 0x55, 0x8f, 0x0a, 0x4a, 0xf5, 0x5e, 0x66, 0x9a, 0x56,
+	0x51, 0x41, 0x81, 0x46, 0x66, 0x40, 0x09, 0xbe, 0x8f, 0x59, 0x76, 0x86, 0x66, 0x40, 0x89, 0x65,
+	0x06, 0x94, 0xe0, 0xfb, 0x99, 0x71, 0x3e, 0x3c, 0x83, 0x50, 0x16, 0x44, 0x29, 0x3e, 0xc0, 0x6c,
+	0x1d, 0x95, 0x05, 0x51, 0x7a, 0x46, 0x66, 0xa1, 0xf2, 0x1e, 0x84, 0xc6, 0x5b, 0x65, 0x16, 0xca,
+	0x4c, 0x8f, 0x0a, 0xaa, 0xec, 0x21, 0x66, 0xd8, 0xad, 0xa2, 0x82, 0x52, 0x3a, 0x80, 0xfa, 0x02,
+	0x3b, 0xad, 0x92, 0x3e, 0xce, 0x8c, 0x93, 0x75, 0x33, 0x12, 0x4e, 0x55, 0xd0, 0x59, 0x68, 0x95,
+	0xb6, 0x1e, 0xb4, 0x02, 0x7a, 0x18, 0x58, 0xda, 0x68, 0x67, 0xd4, 0xfa, 0x51, 0x85, 0x73, 0x10,
+	0x0d, 0x84, 0x42, 0x90, 0x0d, 0xc6, 0x23, 0x0c, 0x3f, 0x71, 0x3f, 0x63, 0x04, 0x22, 0x1b, 0x8d,
+	0x49, 0x84, 0x23, 0xb1, 0x48, 0xba, 0x47, 0x81, 0xae, 0xbd, 0x86, 0x26, 0x14, 0x91, 0xea, 0x9b,
+	0x02, 0x7e, 0xa3, 0xa1, 0x79, 0x0c, 0x38, 0x12, 0x75, 0x34, 0x12, 0x50, 0xeb, 0x68, 0xce, 0x50,
+	0xa2, 0x03, 0xf8, 0x8f, 0x33, 0xfc, 0x56, 0x5b, 0x1a, 0x5f, 0xb8, 0x8a, 0x96, 0xc6, 0x40, 0xf2,
+	0xb6, 0xa0, 0xd5, 0x6a, 0x55, 0x9b, 0xbd, 0xcd, 0xe5, 0x19, 0xa6, 0x6c, 0xa2, 0xb7, 0x09, 0xd6,
+	0xc6, 0xc9, 0x46, 0x8f, 0x33, 0xaa, 0x25, 0x3a, 0xdc, 0xec, 0x5c, 0xc1, 0xfc, 0x55, 0xb3, 0x33,
+	0x10, 0x41, 0x00, 0x0d, 0x1c, 0x43, 0x6b, 0x2c, 0x10, 0x42, 0x0d, 0xaf, 0x64, 0x18, 0x41, 0xf7,
+	0xb3, 0x3a, 0x02, 0x21, 0xd4, 0x71, 0xd4, 0x8a, 0x21, 0x74, 0xf2, 0x2a, 0x86, 0x21, 0xdb, 0xa1,
+	0x28, 0x84, 0x90, 0xcd, 0xed, 0x71, 0x91, 0x50, 0x82, 0xaf, 0x66, 0x08, 0x66, 0x7f, 0x64, 0x8d,
+	0x86, 0x92, 0x25, 0xa2, 0xa1, 0x04, 0x5f, 0xc3, 0x70, 0x82, 0x86, 0xc9, 0x1e, 0x0d, 0x25, 0x4b,
+	0x44, 0x43, 0x09, 0xbe, 0x96, 0x61, 0xc8, 0x0e, 0xca, 0x1e, 0x0d, 0x25, 0xde, 0x76, 0x34, 0x68,
+	0x81, 0x90, 0x2a, 0x7b, 0x1d, 0xc3, 0x50, 0x2d, 0x15, 0x8e, 0xa0, 0x48, 0x8d, 0xae, 0xa2, 0xff,
+	0xb1, 0x45, 0x23, 0x71, 0xae, 0x67, 0x38, 0x5a, 0x8f, 0xb5, 0x26, 0x1a, 0x91, 0xd4, 0xef, 0x31,
+	0x6b, 0x7a, 0x41, 0xc9, 0x6f, 0x60, 0x30, 0x5a, 0xd3, 0x15, 0xcd, 0x2d, 0x68, 0xfb, 0x12, 0x41,
+	0x51, 0x82, 0x6f, 0x64, 0x28, 0xaa, 0x0b, 0x8b, 0x09, 0x8a, 0x92, 0x25, 0x83, 0xa2, 0x04, 0xdf,
+	0xc4, 0x70, 0xb4, 0xb6, 0x2c, 0x2e, 0x28, 0x4a, 0xbc, 0xd3, 0xac, 0x0f, 0x4a, 0x6c, 0x0e, 0xef,
+	0x60, 0x38, 0x91, 0x3e, 0x2d, 0xfa, 0xc4, 0xc4, 0xa6, 0x71, 0xba, 0x7d, 0xe1, 0xc0, 0xf6, 0xf1,
+	0x4e, 0x86, 0x65, 0x6b, 0xdc, 0x2c, 0x6b, 0x08, 0x76, 0x96, 0x3d, 0xd6, 0x7c, 0xc3, 0x1e, 0xf3,
+	0x2e, 0x86, 0xb6, 0x54, 0x27, 0x17, 0x7d, 0x00, 0xb0, 0x0d, 0x5d, 0x88, 0xfe, 0xd7, 0x02, 0xaa,
+	0x6d, 0x48, 0xef, 0xce, 0x24, 0xdc, 0x90, 0x64, 0xd3, 0x35, 0x18, 0x61, 0x56, 0x1b, 0xd4, 0x05,
+	0xe8, 0xff, 0xad, 0xa5, 0xa5, 0x6d, 0x55, 0x37, 0x67, 0xda, 0xdb, 0xaa, 0x24, 0xed, 0x51, 0x96,
+	0x52, 0x0c, 0xf5, 0x7c, 0x73, 0xb5, 0xf1, 0x40, 0x19, 0x9f, 0xca, 0x14, 0x33, 0xd0, 0xf3, 0xc1,
+	0xa8, 0xea, 0xf9, 0x84, 0x15, 0x08, 0xcf, 0xd3, 0xcc, 0x8c, 0xf7, 0x7c, 0x30, 0xac, 0xf5, 0x7c,
+	0xc2, 0x4e, 0xa8, 0xdc, 0x33, 0xcc, 0x90, 0xf7, 0x7c, 0x30, 0xae, 0xf7, 0x7c, 0xc2, 0x52, 0x68,
+	0xd9, 0xb3, 0xcc, 0x32, 0xa7, 0x2c, 0xf5, 0x9e, 0x4f, 0x71, 0x53, 0x82, 0x9f, 0x63, 0x86, 0x19,
+	0x83, 0x5b, 0xf6, 0x30, 0x1a, 0x37, 0x25, 0xf8, 0x6f, 0xcc, 0xd0, 0x33, 0xb9, 0x43, 0x96, 0x42,
+	0x79, 0xfe, 0xce, 0x2c, 0x3b, 0x4c, 0x6e, 0xd9, 0xf3, 0x09, 0x4b, 0x29, 0x0c, 0xff, 0x60, 0xa6,
+	0xbc, 0xe7, 0x83, 0x2f, 0x8c, 0x9e, 0x4f, 0xf2, 0x4b, 0xe3, 0x7f, 0x32, 0x63, 0xde, 0xf3, 0x89,
+	0x19, 0x18, 0x3d, 0x9f, 0x44, 0xe6, 0x4a, 0xf1, 0x2f, 0x66, 0x9a, 0x56, 0x51, 0x69, 0x3d, 0x9f,
+	0x3e, 0x03, 0x4a, 0xf0, 0xbf, 0x99, 0x65, 0x67, 0x68, 0x06, 0xb2, 0xe7, 0x33, 0x66, 0x40, 0x09,
+	0xfe, 0x0f, 0x33, 0xce, 0x87, 0x67, 0x10, 0xca, 0x82, 0x28, 0xeb, 0x23, 0x1d, 0xc5, 0x0c, 0xf4,
+	0x7c, 0x30, 0xae, 0xf7, 0x7c, 0x12, 0x17, 0x8a, 0xf6, 0x75, 0x1d, 0xfc, 0x70, 0x55, 0x65, 0x56,
+	0xeb, 0xf9, 0xe4, 0x6a, 0xe2, 0xf5, 0xf8, 0x7a, 0x66, 0xd8, 0xad, 0xa2, 0xd2, 0x7a, 0x3e, 0x61,
+	0xa7, 0x95, 0xd8, 0x1b, 0x98, 0x71, 0xd2, 0x9e, 0x0f, 0xe0, 0x42, 0x3d, 0x5f, 0xb0, 0x1e, 0xb4,
+	0x42, 0xba, 0x08, 0x58, 0xda, 0xea, 0xf9, 0xe4, 0xfa, 0x09, 0xf5, 0x7c, 0x46, 0x08, 0xb2, 0x09,
+	0xbb, 0x98, 0xe1, 0x3f, 0x8f, 0x9e, 0x4f, 0x0b, 0xc4, 0xe8, 0xf9, 0x42, 0xb1, 0x48, 0xba, 0x4b,
+	0x80, 0xae, 0xdd, 0x9e, 0xcf, 0x88, 0xc8, 0xe8, 0xf9, 0x04, 0x8f, 0xde, 0xf3, 0x5d, 0x0a, 0x1c,
+	0x09, 0x7b, 0x3e, 0x00, 0x0c, 0xf7, 0x7c, 0x30, 0x0a, 0xf8, 0x97, 0x31, 0xfc, 0xd6, 0x7b, 0x3e,
+	0x70, 0x0d, 0x7a, 0x3e, 0x0d, 0xc9, 0x1b, 0xd1, 0x22, 0x98, 0x1b, 0x3f, 0xfb, 0xa0, 0x94, 0xb5,
+	0x27, 0x19, 0x43, 0xd7, 0x58, 0x3a, 0xef, 0xa8, 0x19, 0xed, 0xe6, 0xdf, 0x73, 0x81, 0xdb, 0xa4,
+	0x2d, 0x16, 0xe1, 0x06, 0xa2, 0xf4, 0x3d, 0xe6, 0x97, 0xe5, 0x7e, 0x7d, 0xa6, 0x1f, 0x28, 0xde,
+	0x66, 0x6d, 0x19, 0x08, 0x47, 0x21, 0x7c, 0xdf, 0x67, 0x9e, 0x05, 0xee, 0xd9, 0x6f, 0x7a, 0x0a,
+	0x09, 0xb4, 0xb8, 0x0a, 0x25, 0xfc, 0x01, 0x73, 0xcd, 0xd9, 0x5c, 0x85, 0x26, 0xda, 0xa7, 0x4b,
+	0x09, 0xfe, 0x21, 0xf3, 0xcc, 0xc4, 0x4c, 0x97, 0x1f, 0xba, 0x58, 0xa7, 0x4b, 0x09, 0xfe, 0x11,
+	0xf3, 0xf4, 0xe2, 0xa6, 0x6b, 0x77, 0x15, 0xe2, 0xf9, 0x63, 0xe6, 0xda, 0x11, 0x37, 0x5d, 0x4a,
+	0xbc, 0x13, 0x58, 0x23, 0x6e, 0xba, 0x4a, 0x81, 0xfc, 0x09, 0xf3, 0x75, 0xb9, 0xef, 0x2a, 0xd3,
+	0x57, 0xea, 0xea, 0x16, 0x6d, 0xed, 0xcb, 0x29, 0x4b, 0xef, 0x9f, 0x32, 0xef, 0x5e, 0xee, 0x3d,
+	0x10, 0x9a, 0xf4, 0x64, 0x70, 0x82, 0x16, 0x49, 0x15, 0xe8, 0xed, 0xcf, 0x98, 0x6f, 0xda, 0x96,
+	0x2a, 0x50, 0xde, 0xb8, 0x49, 0x53, 0x82, 0x7f, 0xce, 0x5c, 0x3b, 0x63, 0x27, 0x4d, 0x49, 0xfc,
+	0xa4, 0x29, 0xc1, 0xbf, 0x60, 0xde, 0xf9, 0xf8, 0x49, 0xdb, 0x73, 0x2d, 0x24, 0xfa, 0x97, 0x5c,
+	0xa2, 0x6d, 0xb9, 0x16, 0x62, 0xad, 0x4f, 0x7b, 0xb6, 0x31, 0xab, 0xd7, 0xc0, 0xc3, 0x59, 0x51,
+	0x03, 0x29, 0x35, 0xed, 0x9d, 0xd2, 0x84, 0x97, 0x81, 0x3e, 0x6d, 0xe5, 0x0c, 0x8b, 0xf2, 0x91,
+	0xac, 0xa8, 0x84, 0x94, 0x9a, 0x76, 0xe0, 0x0d, 0xc5, 0xb0, 0x95, 0xf5, 0x79, 0x11, 0x77, 0x51,
+	0x0f, 0x8f, 0x66, 0x45, 0x3d, 0xa4, 0xfc, 0xd5, 0x11, 0x7f, 0x51, 0x12, 0x76, 0x00, 0x51, 0x15,
+	0x8f, 0x65, 0x45, 0x55, 0xd8, 0x00, 0x44, 0x61, 0xc4, 0x06, 0x40, 0x09, 0x7e, 0x3c, 0x2b, 0x6a,
+	0x23, 0x26, 0x00, 0x4a, 0x96, 0x08, 0x80, 0x12, 0xfc, 0x89, 0xac, 0xa8, 0x90, 0xb8, 0x00, 0x62,
+	0x01, 0x44, 0x9d, 0x7c, 0x32, 0x2b, 0xea, 0x24, 0x2e, 0x00, 0xfe, 0x7e, 0x34, 0x68, 0x01, 0x90,
+	0xeb, 0xfd, 0x53, 0x59, 0x51, 0x2d, 0x29, 0x1f, 0x47, 0x10, 0x64, 0xc1, 0x6c, 0x63, 0xef, 0x00,
+	0xd1, 0x20, 0x24, 0xc6, 0xa7, 0xb3, 0xa2, 0x66, 0x52, 0xfe, 0x9a, 0x68, 0x18, 0x93, 0x96, 0xaa,
+	0xd3, 0xe6, 0xc1, 0x2b, 0xe7, 0x33, 0x59, 0x51, 0x39, 0xb6, 0x44, 0x42, 0xf1, 0x2c, 0x11, 0x06,
+	0x25, 0xf8, 0xb3, 0x59, 0x51, 0x3f, 0xb1, 0x61, 0x50, 0xb2, 0x64, 0x18, 0x94, 0xe0, 0xcf, 0x65,
+	0x45, 0x15, 0xc5, 0x87, 0x11, 0xfb, 0x3c, 0x44, 0x2d, 0x3d, 0x91, 0x15, 0xb5, 0x64, 0x7b, 0x1e,
+	0xa2, 0x9c, 0xce, 0x44, 0xb9, 0x99, 0xf1, 0x39, 0x5e, 0x3f, 0x50, 0x44, 0x37, 0x77, 0xf2, 0xad,
+	0x70, 0xa4, 0xa5, 0xad, 0xea, 0xf4, 0xf1, 0x39, 0x56, 0x57, 0xec, 0xbf, 0xed, 0xb3, 0x8b, 0xf3,
+	0x87, 0xfd, 0x95, 0x33, 0x6a, 0xc4, 0x3b, 0x0b, 0xf5, 0x04, 0xd8, 0xb0, 0xc4, 0xdf, 0x03, 0xe0,
+	0xb4, 0x1d, 0x70, 0x5e, 0x7a, 0x80, 0xde, 0x3d, 0xa3, 0x0d, 0x79, 0xaf, 0x45, 0xbd, 0x01, 0xbc,
+	0xa8, 0xc1, 0xf7, 0x02, 0xfe, 0xa6, 0x76, 0xf0, 0xa1, 0x34, 0x81, 0x20, 0x37, 0xa3, 0x8f, 0x19,
+	0x0c, 0xa2, 0x48, 0xdf, 0x97, 0x80, 0x61, 0xaf, 0x85, 0x41, 0xd4, 0x73, 0x28, 0x45, 0x94, 0xe0,
+	0xf7, 0x27, 0x4b, 0x11, 0x25, 0x91, 0x14, 0x51, 0x12, 0x49, 0x11, 0x25, 0xf8, 0x03, 0x09, 0x53,
+	0x24, 0x09, 0xf4, 0x14, 0x85, 0x18, 0x84, 0x0c, 0x7c, 0x30, 0x61, 0x8a, 0xc2, 0x0c, 0x42, 0x31,
+	0xce, 0x46, 0xf9, 0x80, 0x41, 0xd6, 0xf8, 0x87, 0x80, 0xe2, 0xf8, 0x76, 0x28, 0x84, 0x7c, 0x00,
+	0x47, 0xcf, 0x8c, 0x31, 0xe8, 0x4d, 0xa2, 0x82, 0x4a, 0x94, 0x64, 0xf9, 0x30, 0xb0, 0x6c, 0x6e,
+	0x2b, 0x55, 0x93, 0x3a, 0x4d, 0xef, 0x8c, 0x39, 0x6a, 0x3c, 0x6f, 0x10, 0x9b, 0x8f, 0x24, 0x78,
+	0xde, 0x5c, 0x83, 0xcc, 0xe7, 0x0d, 0xb2, 0x14, 0xc9, 0x15, 0x25, 0xf8, 0xa3, 0x49, 0x73, 0x25,
+	0x9f, 0x87, 0x91, 0x2b, 0x4a, 0x2c, 0xb9, 0xa2, 0x04, 0x7f, 0x2c, 0x71, 0xae, 0x24, 0x8d, 0x99,
+	0xab, 0xd0, 0xd2, 0x12, 0x8a, 0x76, 0x4b, 0x82, 0xa5, 0x05, 0x42, 0x67, 0x2e, 0x2d, 0x21, 0x7e,
+	0x46, 0x79, 0xc0, 0x8b, 0xdf, 0xad, 0x49, 0xca, 0x83, 0xbb, 0x86, 0xca, 0x03, 0x5e, 0x18, 0xf5,
+	0xe7, 0x0d, 0x2f, 0x8c, 0xb7, 0x25, 0x78, 0xde, 0xfc, 0xa5, 0xd2, 0x7c, 0xde, 0xf0, 0x9e, 0xa9,
+	0xab, 0x37, 0x7f, 0xf7, 0xbb, 0x3d, 0x81, 0x7a, 0xb3, 0xd7, 0x3d, 0x53, 0xbd, 0xf9, 0x0b, 0xe0,
+	0x02, 0x1a, 0x08, 0xb0, 0xcd, 0x17, 0xc0, 0x3b, 0x80, 0x64, 0x4b, 0x3b, 0x24, 0xfa, 0xeb, 0x1e,
+	0x90, 0xf5, 0xcd, 0x44, 0xbf, 0xf1, 0x0e, 0x23, 0xac, 0x09, 0x96, 0xf9, 0x22, 0x78, 0x27, 0xd0,
+	0x6e, 0x6d, 0x4f, 0xb9, 0xf4, 0xf7, 0x3f, 0x20, 0x5e, 0x35, 0x63, 0xfb, 0xce, 0x9b, 0x41, 0xfd,
+	0x01, 0xb5, 0xfe, 0x6e, 0x78, 0x17, 0xd0, 0x9e, 0xd0, 0x0e, 0xad, 0x7a, 0x17, 0x04, 0xca, 0xc2,
+	0x4c, 0x78, 0x5c, 0xae, 0x0c, 0xbe, 0x0d, 0xc0, 0xce, 0x7b, 0x77, 0x9b, 0x2b, 0x83, 0xef, 0x82,
+	0x6a, 0xeb, 0x65, 0x2b, 0x23, 0x18, 0x92, 0x4b, 0x7b, 0x41, 0xc3, 0xbf, 0xa7, 0xcd, 0xa5, 0x0d,
+	0x9b, 0xa0, 0x22, 0x60, 0x4b, 0x4d, 0x8d, 0x49, 0x86, 0xa6, 0xc6, 0x70, 0x6f, 0x9b, 0x0c, 0x7b,
+	0x2d, 0x0c, 0x6a, 0x4c, 0x4b, 0x11, 0x25, 0x40, 0x70, 0x5f, 0xfb, 0x29, 0xa2, 0x24, 0x92, 0x22,
+	0x18, 0xd2, 0x53, 0x24, 0xf1, 0xef, 0x4f, 0x90, 0x22, 0x9d, 0x40, 0xa6, 0xc8, 0x64, 0x68, 0x6a,
+	0x0c, 0x0f, 0x24, 0x48, 0x51, 0x98, 0x41, 0x8d, 0x49, 0xc1, 0x17, 0xdb, 0x0b, 0x50, 0x3c, 0xd8,
+	0xa6, 0xe0, 0x8b, 0x3d, 0x50, 0x71, 0xb0, 0xac, 0x6b, 0x83, 0x41, 0xa2, 0xb8, 0xa4, 0x01, 0xc7,
+	0x43, 0xed, 0x26, 0x8a, 0xfb, 0x86, 0x12, 0x15, 0x8c, 0x79, 0x45, 0x84, 0x1a, 0xb3, 0xb5, 0xc6,
+	0x24, 0x80, 0x5f, 0xe4, 0x16, 0x9d, 0x52, 0x57, 0x35, 0xe5, 0xaf, 0xe0, 0x83, 0xdc, 0x62, 0x2d,
+	0x5a, 0x09, 0x16, 0xd0, 0x86, 0x5d, 0xcc, 0x4c, 0xb2, 0xd5, 0x94, 0x0f, 0x7e, 0xd0, 0x10, 0x1e,
+	0x8d, 0xba, 0xc1, 0x46, 0x74, 0x83, 0x97, 0x30, 0xa3, 0x42, 0x35, 0xe5, 0x83, 0xab, 0x68, 0xea,
+	0x02, 0x2b, 0xd1, 0xd1, 0x5d, 0xca, 0xac, 0x72, 0x81, 0x95, 0x68, 0xcc, 0x74, 0x3e, 0x4a, 0xf0,
+	0x65, 0xcc, 0x28, 0xa3, 0xf3, 0x51, 0x62, 0xf2, 0x51, 0x82, 0xdf, 0xc8, 0x8c, 0x3c, 0x83, 0x4f,
+	0xb7, 0x12, 0xed, 0xd1, 0x9b, 0x98, 0x55, 0x87, 0xc1, 0x47, 0x89, 0x77, 0x0c, 0xca, 0x81, 0x95,
+	0x6c, 0x3e, 0xde, 0xcc, 0xcc, 0xdc, 0x6a, 0xca, 0x07, 0x6f, 0xd9, 0xa8, 0x94, 0x50, 0x8f, 0xe0,
+	0x94, 0x86, 0x6f, 0x61, 0x86, 0xbd, 0xd5, 0x94, 0x0f, 0x00, 0x41, 0xab, 0x11, 0x44, 0x00, 0x7d,
+	0xc6, 0x5b, 0x99, 0x59, 0x3a, 0x88, 0x00, 0xfa, 0x05, 0x93, 0x95, 0x12, 0xfc, 0x36, 0x66, 0xd5,
+	0x69, 0xb2, 0xf2, 0xb3, 0x54, 0x83, 0x95, 0x12, 0xfc, 0x76, 0x66, 0x98, 0x0f, 0xb1, 0xea, 0xd1,
+	0x8a, 0x1d, 0xfb, 0x72, 0x66, 0xe7, 0x04, 0xd1, 0x8a, 0x8d, 0x57, 0x65, 0x0e, 0x76, 0xdd, 0x2b,
+	0x98, 0xd5, 0x0a, 0x95, 0x39, 0xd8, 0x3c, 0x83, 0x08, 0x60, 0xe7, 0xbc, 0x92, 0x19, 0x75, 0x07,
+	0x11, 0xc0, 0x0e, 0xf8, 0x1a, 0x94, 0x07, 0x1b, 0xed, 0x98, 0xf5, 0x2a, 0x37, 0xe1, 0x25, 0x95,
+	0x6a, 0xca, 0x87, 0x38, 0xd5, 0x29, 0xeb, 0x19, 0xc8, 0x93, 0xcf, 0x58, 0x3b, 0x62, 0xbd, 0xda,
+	0x6d, 0xef, 0x5e, 0x4a, 0x35, 0xe5, 0xe7, 0xc5, 0x9a, 0x50, 0x27, 0xac, 0x53, 0xa8, 0x4f, 0x9f,
+	0xba, 0xdc, 0xe6, 0xae, 0x71, 0x93, 0x5f, 0x11, 0xac, 0xa6, 0xfc, 0x82, 0x0a, 0x40, 0xee, 0x6c,
+	0x07, 0xd0, 0x2a, 0x33, 0x06, 0x49, 0x75, 0xad, 0xdb, 0xf6, 0xfd, 0xc0, 0x6a, 0xca, 0xef, 0xd3,
+	0x23, 0x91, 0x1c, 0xe3, 0x08, 0x88, 0x8d, 0xad, 0xf3, 0x3a, 0x37, 0xe9, 0xe5, 0xc0, 0x6a, 0xca,
+	0xef, 0xe5, 0x78, 0xda, 0x8e, 0xe9, 0x0b, 0x91, 0x00, 0xec, 0xeb, 0x5d, 0x7e, 0x33, 0xf0, 0xa5,
+	0xad, 0xdd, 0x0c, 0x64, 0x7e, 0x12, 0x58, 0x43, 0x51, 0x05, 0x00, 0x0b, 0x71, 0x08, 0xdf, 0x20,
+	0x57, 0x62, 0xb7, 0xb6, 0x12, 0x87, 0xc2, 0x76, 0x65, 0x7c, 0xa3, 0xcd, 0xae, 0x1c, 0xb6, 0x1b,
+	0xc6, 0x37, 0xd9, 0xec, 0x86, 0xbd, 0xcd, 0xa8, 0x5f, 0x94, 0x89, 0xf9, 0xbb, 0xfd, 0xaf, 0x5c,
+	0x75, 0x27, 0xb1, 0xea, 0xf8, 0xb0, 0xf6, 0xcc, 0x9f, 0xed, 0xb7, 0xc8, 0xa7, 0x19, 0xfe, 0xcd,
+	0xfe, 0xd7, 0xae, 0x7e, 0x41, 0xb1, 0xea, 0x88, 0x07, 0x15, 0xfa, 0xc9, 0xfe, 0x24, 0x34, 0x10,
+	0x76, 0x17, 0x72, 0xf9, 0x1b, 0x57, 0xbb, 0xad, 0x58, 0x75, 0xfc, 0x7e, 0xd3, 0x7d, 0x8f, 0x3c,
+	0x81, 0x8a, 0xf8, 0x0b, 0x21, 0xfd, 0xad, 0xab, 0xae, 0x2e, 0x46, 0xdd, 0xf7, 0xca, 0x5f, 0xfb,
+	0x6d, 0xb3, 0xa7, 0x04, 0xff, 0xce, 0x0d, 0xdf, 0x63, 0xb4, 0x46, 0x40, 0x49, 0x5c, 0x04, 0x94,
+	0xe0, 0xdf, 0xbb, 0xda, 0xa5, 0x46, 0x7b, 0x04, 0xfc, 0xec, 0xd2, 0x1a, 0x01, 0x25, 0xf8, 0x0f,
+	0xae, 0xba, 0xe1, 0x68, 0x8f, 0x80, 0x9f, 0x60, 0xad, 0x0e, 0xbb, 0x4b, 0x29, 0xfe, 0xa3, 0xab,
+	0x5f, 0x77, 0xac, 0x3a, 0xfe, 0x2a, 0x13, 0x41, 0x8a, 0xf8, 0xc9, 0x08, 0x47, 0x22, 0x90, 0x18,
+	0x7f, 0x72, 0x8d, 0xbb, 0x8f, 0x55, 0xc7, 0x1f, 0x08, 0x45, 0x21, 0x05, 0xfe, 0xa4, 0x68, 0x2a,
+	0x41, 0xea, 0xff, 0xec, 0x1a, 0x17, 0x21, 0xa3, 0x79, 0x94, 0x67, 0x58, 0xf6, 0x40, 0x28, 0xc1,
+	0x7f, 0x71, 0xf5, 0x5b, 0x91, 0x31, 0x81, 0x50, 0x12, 0x1f, 0x08, 0x25, 0xf8, 0xaf, 0xae, 0x71,
+	0x45, 0x32, 0x2e, 0x10, 0x4a, 0xbc, 0x53, 0xa2, 0x0f, 0x44, 0xec, 0x1e, 0x4f, 0xb9, 0x96, 0xfb,
+	0x92, 0xd1, 0x27, 0x23, 0x76, 0x95, 0x53, 0x2d, 0x0b, 0x03, 0xf6, 0x97, 0xa7, 0x5d, 0xfb, 0xe5,
+	0x49, 0xcb, 0x1a, 0x81, 0xad, 0x67, 0x57, 0x34, 0xb7, 0xb0, 0x09, 0x3d, 0xe3, 0x2e, 0x7d, 0x93,
+	0x32, 0x9a, 0x6c, 0xd8, 0xa7, 0x0e, 0xa1, 0xc1, 0x30, 0xa0, 0xb6, 0x63, 0x3d, 0xeb, 0x3e, 0xbf,
+	0x6b, 0x95, 0x55, 0xc7, 0x5f, 0x6d, 0xb2, 0xaa, 0x1d, 0x6c, 0x01, 0x1d, 0x15, 0x2d, 0x17, 0x6d,
+	0x2f, 0x7b, 0xce, 0x4d, 0x74, 0xc7, 0xb2, 0xea, 0xf8, 0x6b, 0xc2, 0xe5, 0x15, 0xd8, 0x0c, 0x8e,
+	0xa2, 0xde, 0xd0, 0xd6, 0xd4, 0xee, 0x3f, 0x6a, 0x19, 0xdc, 0x8a, 0x72, 0xc6, 0x96, 0x90, 0x04,
+	0xc0, 0xb8, 0x11, 0x9e, 0x04, 0xc0, 0xb8, 0x7f, 0x95, 0x0c, 0x40, 0xfb, 0x31, 0xaf, 0x6d, 0x80,
+	0x93, 0x50, 0x3e, 0x7c, 0xc4, 0xea, 0xe5, 0x51, 0xe6, 0x60, 0xed, 0x30, 0x07, 0xe9, 0xf2, 0xd9,
+	0x9f, 0x5e, 0x3f, 0xca, 0x9e, 0x3f, 0x5e, 0x6f, 0xd6, 0x70, 0x9a, 0x8f, 0xc1, 0x87, 0x4a, 0xfa,
+	0x78, 0x67, 0x70, 0x2b, 0x2a, 0x44, 0x4e, 0x51, 0x97, 0x03, 0xc8, 0xea, 0x00, 0x2f, 0x43, 0x5e,
+	0xf4, 0x98, 0x74, 0x39, 0x84, 0x82, 0x1d, 0x61, 0x6f, 0xeb, 0x08, 0xb9, 0xd8, 0x20, 0xc4, 0x69,
+	0xd1, 0x72, 0x00, 0x99, 0xf8, 0x20, 0x5a, 0x44, 0xf0, 0xe2, 0x83, 0x68, 0x11, 0xa1, 0x43, 0x47,
+	0x18, 0x45, 0x7d, 0x96, 0x73, 0xc8, 0xe5, 0x20, 0x5c, 0x1d, 0x62, 0x0c, 0xf5, 0xdb, 0x0e, 0x19,
+	0x97, 0xc3, 0xe8, 0xb5, 0xe7, 0x52, 0x9d, 0x21, 0x2e, 0x07, 0x90, 0x5e, 0x22, 0x8e, 0x16, 0x53,
+	0xd1, 0xb9, 0x54, 0x1c, 0x2d, 0x62, 0xe4, 0xed, 0x0f, 0x44, 0x3b, 0xde, 0x5b, 0x0e, 0xc1, 0x89,
+	0x59, 0x14, 0xea, 0xf8, 0x6e, 0x39, 0x84, 0x15, 0xf6, 0x5c, 0xaa, 0xf3, 0xb9, 0xe5, 0x00, 0xba,
+	0x75, 0x80, 0x89, 0xa0, 0xba, 0x83, 0x23, 0x38, 0x8b, 0x7f, 0x45, 0xf7, 0xef, 0x29, 0x1f, 0xbd,
+	0xf4, 0x1e, 0x31, 0x3e, 0xc7, 0xaf, 0x74, 0x68, 0x2c, 0x17, 0x22, 0x1c, 0x77, 0x06, 0x67, 0x61,
+	0x3b, 0x4d, 0x67, 0x4b, 0x7a, 0xc9, 0x43, 0x63, 0x6f, 0xa2, 0xc1, 0xf8, 0xa3, 0x38, 0x0b, 0xff,
+	0xa8, 0xc9, 0xdf, 0xd6, 0xad, 0x0f, 0x8d, 0xf6, 0x10, 0x1a, 0xb0, 0x1f, 0xc5, 0x59, 0x28, 0xab,
+	0x26, 0x65, 0x92, 0x4b, 0x20, 0x91, 0x55, 0x61, 0x9e, 0xcd, 0xe9, 0xa4, 0xd9, 0xe5, 0x34, 0x1b,
+	0x16, 0x66, 0xe8, 0xf0, 0x4d, 0x47, 0x28, 0xb4, 0x86, 0xb0, 0x37, 0x1e, 0x21, 0xd7, 0xda, 0xbe,
+	0x61, 0x9e, 0x9e, 0xe9, 0x00, 0x99, 0xd6, 0x83, 0x88, 0x41, 0xf0, 0x5a, 0x0f, 0x22, 0x06, 0xa1,
+	0x63, 0x39, 0x04, 0x90, 0xaa, 0xf0, 0xe9, 0x96, 0x0e, 0xe1, 0xb6, 0x18, 0x86, 0x79, 0x78, 0xa5,
+	0x23, 0xac, 0x58, 0x0e, 0xe1, 0x44, 0x84, 0xd4, 0xcb, 0x67, 0xdb, 0xff, 0xb0, 0x77, 0x08, 0x75,
+	0xeb, 0xdd, 0x9e, 0xb7, 0x02, 0x41, 0xf3, 0x95, 0x47, 0xec, 0xcf, 0x31, 0x7f, 0xf4, 0x95, 0xbb,
+	0xf2, 0xfd, 0xde, 0x4a, 0xe4, 0x6e, 0xab, 0x8e, 0xfa, 0x3b, 0x4e, 0xdd, 0x9e, 0xff, 0xbf, 0x75,
+	0x2b, 0xba, 0x2e, 0xdf, 0x99, 0x3f, 0x72, 0xe4, 0xc8, 0x91, 0xf4, 0x58, 0x4e, 0x9e, 0x9f, 0x34,
+	0x67, 0xa7, 0x1b, 0xb3, 0x63, 0xab, 0xa3, 0x3d, 0x2d, 0xff, 0x62, 0x5d, 0x09, 0xfe, 0xf5, 0x30,
+	0x48, 0x87, 0xd7, 0x85, 0x3a, 0xce, 0xdc, 0xee, 0xef, 0xca, 0xa7, 0x3c, 0x17, 0x65, 0x76, 0xed,
+	0xdc, 0x9e, 0x77, 0xd8, 0x1f, 0xaf, 0x78, 0xd5, 0xae, 0x7c, 0x7a, 0xdd, 0x08, 0xea, 0x31, 0x9b,
+	0x41, 0x35, 0xa3, 0x09, 0x0f, 0xc9, 0x19, 0x3d, 0xe1, 0x78, 0xdd, 0x6a, 0x4a, 0xb7, 0xa4, 0xff,
+	0x1b, 0x00, 0x00, 0xff, 0xff, 0x7b, 0xc1, 0x4f, 0x87, 0x12, 0x3d, 0x00, 0x00,
+}

internal/impl/legacy_proto3_test.go

@@ -0,0 +1,422 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package impl
+
+// TODO: Move this to a separate package. We do *not* want this to be
+// auto-generated by the current protoc-gen-go since it is supposed to be a
+// snapshot of an generated message from the past.
+
+import "github.com/golang/protobuf/proto"
+
+type LP3SiblingEnum int32
+
+func (LP3SiblingEnum) EnumDescriptor() ([]byte, []int) {
+	return LP3FileDescriptor, []int{0}
+}
+
+type LP3Message_LP3ChildEnum int32
+
+func (LP3Message_LP3ChildEnum) EnumDescriptor() ([]byte, []int) {
+	return LP3FileDescriptor, []int{1, 0}
+}
+
+type LP3SiblingMessage struct {
+	F1                   string   `protobuf:"bytes,1,opt,name=f1,proto3" json:"f1,omitempty"`
+	F2                   []string `protobuf:"bytes,2,rep,name=f2,proto3" json:"f2,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP3SiblingMessage) Descriptor() ([]byte, []int) {
+	return LP3FileDescriptor, []int{0}
+}
+
+type LP3Message struct {
+	// Optional fields.
+	OptionalBool           bool                        `protobuf:"varint,100,opt,name=optional_bool,json=optionalBool,proto3" json:"optional_bool,omitempty"`
+	OptionalInt32          int32                       `protobuf:"varint,101,opt,name=optional_int32,json=optionalInt32,proto3" json:"optional_int32,omitempty"`
+	OptionalSint32         int32                       `protobuf:"zigzag32,102,opt,name=optional_sint32,json=optionalSint32,proto3" json:"optional_sint32,omitempty"`
+	OptionalUint32         uint32                      `protobuf:"varint,103,opt,name=optional_uint32,json=optionalUint32,proto3" json:"optional_uint32,omitempty"`
+	OptionalInt64          int64                       `protobuf:"varint,104,opt,name=optional_int64,json=optionalInt64,proto3" json:"optional_int64,omitempty"`
+	OptionalSint64         int64                       `protobuf:"zigzag64,105,opt,name=optional_sint64,json=optionalSint64,proto3" json:"optional_sint64,omitempty"`
+	OptionalUint64         uint64                      `protobuf:"varint,106,opt,name=optional_uint64,json=optionalUint64,proto3" json:"optional_uint64,omitempty"`
+	OptionalFixed32        uint32                      `protobuf:"fixed32,107,opt,name=optional_fixed32,json=optionalFixed32,proto3" json:"optional_fixed32,omitempty"`
+	OptionalSfixed32       int32                       `protobuf:"fixed32,108,opt,name=optional_sfixed32,json=optionalSfixed32,proto3" json:"optional_sfixed32,omitempty"`
+	OptionalFloat          float32                     `protobuf:"fixed32,109,opt,name=optional_float,json=optionalFloat,proto3" json:"optional_float,omitempty"`
+	OptionalFixed64        uint64                      `protobuf:"fixed64,110,opt,name=optional_fixed64,json=optionalFixed64,proto3" json:"optional_fixed64,omitempty"`
+	OptionalSfixed64       int64                       `protobuf:"fixed64,111,opt,name=optional_sfixed64,json=optionalSfixed64,proto3" json:"optional_sfixed64,omitempty"`
+	OptionalDouble         float64                     `protobuf:"fixed64,112,opt,name=optional_double,json=optionalDouble,proto3" json:"optional_double,omitempty"`
+	OptionalString         string                      `protobuf:"bytes,113,opt,name=optional_string,json=optionalString,proto3" json:"optional_string,omitempty"`
+	OptionalBytes          []byte                      `protobuf:"bytes,114,opt,name=optional_bytes,json=optionalBytes,proto3" json:"optional_bytes,omitempty"`
+	OptionalChildEnum      LP3Message_LP3ChildEnum     `protobuf:"varint,115,opt,name=optional_child_enum,json=optionalChildEnum,proto3,enum=google.golang.org.proto3.LP3Message_LP3ChildEnum" json:"optional_child_enum,omitempty"`
+	OptionalSiblingEnum    LP3SiblingEnum              `protobuf:"varint,116,opt,name=optional_sibling_enum,json=optionalSiblingEnum,proto3,enum=google.golang.org.proto3.LP3SiblingEnum" json:"optional_sibling_enum,omitempty"`
+	OptionalChildMessage   *LP3Message_LP3ChildMessage `protobuf:"bytes,117,opt,name=optional_child_message,json=optionalChildMessage,proto3" json:"optional_child_message,omitempty"`
+	OptionalSiblingMessage *LP3SiblingMessage          `protobuf:"bytes,118,opt,name=optional_sibling_message,json=optionalSiblingMessage,proto3" json:"optional_sibling_message,omitempty"`
+	// Repeated fields.
+	RepeatedBool           []bool                        `protobuf:"varint,200,rep,packed,name=repeated_bool,json=repeatedBool,proto3" json:"repeated_bool,omitempty"`
+	RepeatedInt32          []int32                       `protobuf:"varint,201,rep,packed,name=repeated_int32,json=repeatedInt32,proto3" json:"repeated_int32,omitempty"`
+	RepeatedSint32         []int32                       `protobuf:"zigzag32,202,rep,packed,name=repeated_sint32,json=repeatedSint32,proto3" json:"repeated_sint32,omitempty"`
+	RepeatedUint32         []uint32                      `protobuf:"varint,203,rep,packed,name=repeated_uint32,json=repeatedUint32,proto3" json:"repeated_uint32,omitempty"`
+	RepeatedInt64          []int64                       `protobuf:"varint,204,rep,packed,name=repeated_int64,json=repeatedInt64,proto3" json:"repeated_int64,omitempty"`
+	RepeatedSint64         []int64                       `protobuf:"zigzag64,205,rep,packed,name=repeated_sint64,json=repeatedSint64,proto3" json:"repeated_sint64,omitempty"`
+	RepeatedUint64         []uint64                      `protobuf:"varint,206,rep,packed,name=repeated_uint64,json=repeatedUint64,proto3" json:"repeated_uint64,omitempty"`
+	RepeatedFixed32        []uint32                      `protobuf:"fixed32,207,rep,packed,name=repeated_fixed32,json=repeatedFixed32,proto3" json:"repeated_fixed32,omitempty"`
+	RepeatedSfixed32       []int32                       `protobuf:"fixed32,208,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32,proto3" json:"repeated_sfixed32,omitempty"`
+	RepeatedFloat          []float32                     `protobuf:"fixed32,209,rep,packed,name=repeated_float,json=repeatedFloat,proto3" json:"repeated_float,omitempty"`
+	RepeatedFixed64        []uint64                      `protobuf:"fixed64,210,rep,packed,name=repeated_fixed64,json=repeatedFixed64,proto3" json:"repeated_fixed64,omitempty"`
+	RepeatedSfixed64       []int64                       `protobuf:"fixed64,211,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64,proto3" json:"repeated_sfixed64,omitempty"`
+	RepeatedDouble         []float64                     `protobuf:"fixed64,212,rep,packed,name=repeated_double,json=repeatedDouble,proto3" json:"repeated_double,omitempty"`
+	RepeatedString         []string                      `protobuf:"bytes,213,rep,name=repeated_string,json=repeatedString,proto3" json:"repeated_string,omitempty"`
+	RepeatedBytes          [][]byte                      `protobuf:"bytes,214,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
+	RepeatedChildEnum      []LP3Message_LP3ChildEnum     `protobuf:"varint,215,rep,packed,name=repeated_child_enum,json=repeatedChildEnum,proto3,enum=google.golang.org.proto3.LP3Message_LP3ChildEnum" json:"repeated_child_enum,omitempty"`
+	RepeatedSiblingEnum    []LP3SiblingEnum              `protobuf:"varint,216,rep,packed,name=repeated_sibling_enum,json=repeatedSiblingEnum,proto3,enum=google.golang.org.proto3.LP3SiblingEnum" json:"repeated_sibling_enum,omitempty"`
+	RepeatedChildMessage   []*LP3Message_LP3ChildMessage `protobuf:"bytes,217,rep,name=repeated_child_message,json=repeatedChildMessage,proto3" json:"repeated_child_message,omitempty"`
+	RepeatedSiblingMessage []*LP3SiblingMessage          `protobuf:"bytes,218,rep,name=repeated_sibling_message,json=repeatedSiblingMessage,proto3" json:"repeated_sibling_message,omitempty"`
+	// Repeated packed fields.
+	RepeatedPackedBool     []bool    `protobuf:"varint,300,rep,packed,name=repeated_packed_bool,json=repeatedPackedBool,proto3" json:"repeated_packed_bool,omitempty"`
+	RepeatedPackedInt32    []int32   `protobuf:"varint,301,rep,packed,name=repeated_packed_int32,json=repeatedPackedInt32,proto3" json:"repeated_packed_int32,omitempty"`
+	RepeatedPackedSint32   []int32   `protobuf:"zigzag32,302,rep,packed,name=repeated_packed_sint32,json=repeatedPackedSint32,proto3" json:"repeated_packed_sint32,omitempty"`
+	RepeatedPackedUint32   []uint32  `protobuf:"varint,303,rep,packed,name=repeated_packed_uint32,json=repeatedPackedUint32,proto3" json:"repeated_packed_uint32,omitempty"`
+	RepeatedPackedInt64    []int64   `protobuf:"varint,304,rep,packed,name=repeated_packed_int64,json=repeatedPackedInt64,proto3" json:"repeated_packed_int64,omitempty"`
+	RepeatedPackedSint64   []int64   `protobuf:"zigzag64,305,rep,packed,name=repeated_packed_sint64,json=repeatedPackedSint64,proto3" json:"repeated_packed_sint64,omitempty"`
+	RepeatedPackedUint64   []uint64  `protobuf:"varint,306,rep,packed,name=repeated_packed_uint64,json=repeatedPackedUint64,proto3" json:"repeated_packed_uint64,omitempty"`
+	RepeatedPackedFixed32  []uint32  `protobuf:"fixed32,307,rep,packed,name=repeated_packed_fixed32,json=repeatedPackedFixed32,proto3" json:"repeated_packed_fixed32,omitempty"`
+	RepeatedPackedSfixed32 []int32   `protobuf:"fixed32,308,rep,packed,name=repeated_packed_sfixed32,json=repeatedPackedSfixed32,proto3" json:"repeated_packed_sfixed32,omitempty"`
+	RepeatedPackedFloat    []float32 `protobuf:"fixed32,309,rep,packed,name=repeated_packed_float,json=repeatedPackedFloat,proto3" json:"repeated_packed_float,omitempty"`
+	RepeatedPackedFixed64  []uint64  `protobuf:"fixed64,310,rep,packed,name=repeated_packed_fixed64,json=repeatedPackedFixed64,proto3" json:"repeated_packed_fixed64,omitempty"`
+	RepeatedPackedSfixed64 []int64   `protobuf:"fixed64,311,rep,packed,name=repeated_packed_sfixed64,json=repeatedPackedSfixed64,proto3" json:"repeated_packed_sfixed64,omitempty"`
+	RepeatedPackedDouble   []float64 `protobuf:"fixed64,312,rep,packed,name=repeated_packed_double,json=repeatedPackedDouble,proto3" json:"repeated_packed_double,omitempty"`
+	// Repeated non-packed fields.
+	RepeatedNonpackedBool     []bool    `protobuf:"varint,400,rep,name=repeated_nonpacked_bool,json=repeatedNonpackedBool,proto3" json:"repeated_nonpacked_bool,omitempty"`
+	RepeatedNonpackedInt32    []int32   `protobuf:"varint,401,rep,name=repeated_nonpacked_int32,json=repeatedNonpackedInt32,proto3" json:"repeated_nonpacked_int32,omitempty"`
+	RepeatedNonpackedSint32   []int32   `protobuf:"zigzag32,402,rep,name=repeated_nonpacked_sint32,json=repeatedNonpackedSint32,proto3" json:"repeated_nonpacked_sint32,omitempty"`
+	RepeatedNonpackedUint32   []uint32  `protobuf:"varint,403,rep,name=repeated_nonpacked_uint32,json=repeatedNonpackedUint32,proto3" json:"repeated_nonpacked_uint32,omitempty"`
+	RepeatedNonpackedInt64    []int64   `protobuf:"varint,404,rep,name=repeated_nonpacked_int64,json=repeatedNonpackedInt64,proto3" json:"repeated_nonpacked_int64,omitempty"`
+	RepeatedNonpackedSint64   []int64   `protobuf:"zigzag64,405,rep,name=repeated_nonpacked_sint64,json=repeatedNonpackedSint64,proto3" json:"repeated_nonpacked_sint64,omitempty"`
+	RepeatedNonpackedUint64   []uint64  `protobuf:"varint,406,rep,name=repeated_nonpacked_uint64,json=repeatedNonpackedUint64,proto3" json:"repeated_nonpacked_uint64,omitempty"`
+	RepeatedNonpackedFixed32  []uint32  `protobuf:"fixed32,407,rep,name=repeated_nonpacked_fixed32,json=repeatedNonpackedFixed32,proto3" json:"repeated_nonpacked_fixed32,omitempty"`
+	RepeatedNonpackedSfixed32 []int32   `protobuf:"fixed32,408,rep,name=repeated_nonpacked_sfixed32,json=repeatedNonpackedSfixed32,proto3" json:"repeated_nonpacked_sfixed32,omitempty"`
+	RepeatedNonpackedFloat    []float32 `protobuf:"fixed32,409,rep,name=repeated_nonpacked_float,json=repeatedNonpackedFloat,proto3" json:"repeated_nonpacked_float,omitempty"`
+	RepeatedNonpackedFixed64  []uint64  `protobuf:"fixed64,410,rep,name=repeated_nonpacked_fixed64,json=repeatedNonpackedFixed64,proto3" json:"repeated_nonpacked_fixed64,omitempty"`
+	RepeatedNonpackedSfixed64 []int64   `protobuf:"fixed64,411,rep,name=repeated_nonpacked_sfixed64,json=repeatedNonpackedSfixed64,proto3" json:"repeated_nonpacked_sfixed64,omitempty"`
+	RepeatedNonpackedDouble   []float64 `protobuf:"fixed64,412,rep,name=repeated_nonpacked_double,json=repeatedNonpackedDouble,proto3" json:"repeated_nonpacked_double,omitempty"`
+	// Map fields.
+	MapBoolBool           map[bool]bool                        `protobuf:"bytes,500,rep,name=map_bool_bool,json=mapBoolBool,proto3" json:"map_bool_bool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapBoolInt32          map[bool]int32                       `protobuf:"bytes,501,rep,name=map_bool_int32,json=mapBoolInt32,proto3" json:"map_bool_int32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapBoolSint32         map[bool]int32                       `protobuf:"bytes,502,rep,name=map_bool_sint32,json=mapBoolSint32,proto3" json:"map_bool_sint32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"zigzag32,2,opt,name=value,proto3"`
+	MapBoolUint32         map[bool]uint32                      `protobuf:"bytes,503,rep,name=map_bool_uint32,json=mapBoolUint32,proto3" json:"map_bool_uint32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapBoolInt64          map[bool]int64                       `protobuf:"bytes,504,rep,name=map_bool_int64,json=mapBoolInt64,proto3" json:"map_bool_int64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapBoolSint64         map[bool]int64                       `protobuf:"bytes,505,rep,name=map_bool_sint64,json=mapBoolSint64,proto3" json:"map_bool_sint64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
+	MapBoolUint64         map[bool]uint64                      `protobuf:"bytes,506,rep,name=map_bool_uint64,json=mapBoolUint64,proto3" json:"map_bool_uint64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapBoolFixed32        map[bool]uint32                      `protobuf:"bytes,507,rep,name=map_bool_fixed32,json=mapBoolFixed32,proto3" json:"map_bool_fixed32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapBoolSfixed32       map[bool]int32                       `protobuf:"bytes,508,rep,name=map_bool_sfixed32,json=mapBoolSfixed32,proto3" json:"map_bool_sfixed32,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapBoolFloat          map[bool]float32                     `protobuf:"bytes,509,rep,name=map_bool_float,json=mapBoolFloat,proto3" json:"map_bool_float,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed32,2,opt,name=value,proto3"`
+	MapBoolFixed64        map[bool]uint64                      `protobuf:"bytes,510,rep,name=map_bool_fixed64,json=mapBoolFixed64,proto3" json:"map_bool_fixed64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapBoolSfixed64       map[bool]int64                       `protobuf:"bytes,511,rep,name=map_bool_sfixed64,json=mapBoolSfixed64,proto3" json:"map_bool_sfixed64,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapBoolDouble         map[bool]float64                     `protobuf:"bytes,512,rep,name=map_bool_double,json=mapBoolDouble,proto3" json:"map_bool_double,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"fixed64,2,opt,name=value,proto3"`
+	MapBoolString         map[bool]string                      `protobuf:"bytes,513,rep,name=map_bool_string,json=mapBoolString,proto3" json:"map_bool_string,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapBoolBytes          map[bool][]byte                      `protobuf:"bytes,514,rep,name=map_bool_bytes,json=mapBoolBytes,proto3" json:"map_bool_bytes,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapBoolChildEnum      map[bool]LP3Message_LP3ChildEnum     `protobuf:"bytes,515,rep,name=map_bool_child_enum,json=mapBoolChildEnum,proto3" json:"map_bool_child_enum,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=google.golang.org.proto3.LP3Message_LP3ChildEnum"`
+	MapBoolSiblingEnum    map[bool]LP3SiblingEnum              `protobuf:"bytes,516,rep,name=map_bool_sibling_enum,json=mapBoolSiblingEnum,proto3" json:"map_bool_sibling_enum,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=google.golang.org.proto3.LP3SiblingEnum"`
+	MapBoolChildMessage   map[bool]*LP3Message_LP3ChildMessage `protobuf:"bytes,517,rep,name=map_bool_child_message,json=mapBoolChildMessage,proto3" json:"map_bool_child_message,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapBoolSiblingMessage map[bool]*LP3SiblingMessage          `protobuf:"bytes,518,rep,name=map_bool_sibling_message,json=mapBoolSiblingMessage,proto3" json:"map_bool_sibling_message,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	MapInt32Bool          map[int32]bool                       `protobuf:"bytes,519,rep,name=map_int32_bool,json=mapInt32Bool,proto3" json:"map_int32_bool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapSint32Bool         map[int32]bool                       `protobuf:"bytes,520,rep,name=map_sint32_bool,json=mapSint32Bool,proto3" json:"map_sint32_bool,omitempty" protobuf_key:"zigzag32,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapUint32Bool         map[uint32]bool                      `protobuf:"bytes,521,rep,name=map_uint32_bool,json=mapUint32Bool,proto3" json:"map_uint32_bool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapInt64Bool          map[int64]bool                       `protobuf:"bytes,522,rep,name=map_int64_bool,json=mapInt64Bool,proto3" json:"map_int64_bool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapSint64Bool         map[int64]bool                       `protobuf:"bytes,523,rep,name=map_sint64_bool,json=mapSint64Bool,proto3" json:"map_sint64_bool,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapUint64Bool         map[uint64]bool                      `protobuf:"bytes,524,rep,name=map_uint64_bool,json=mapUint64Bool,proto3" json:"map_uint64_bool,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapFixed32Bool        map[uint32]bool                      `protobuf:"bytes,525,rep,name=map_fixed32_bool,json=mapFixed32Bool,proto3" json:"map_fixed32_bool,omitempty" protobuf_key:"fixed32,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	MapStringBool         map[string]bool                      `protobuf:"bytes,526,rep,name=map_string_bool,json=mapStringBool,proto3" json:"map_string_bool,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
+	// Oneof fields.
+	OneofUnion           isLP3Message_OneofUnion `protobuf_oneof:"oneof_union"`
+	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
+	XXX_unrecognized     []byte                  `json:"-"`
+	XXX_sizecache        int32                   `json:"-"`
+}
+
+func (*LP3Message) Descriptor() ([]byte, []int) {
+	return LP3FileDescriptor, []int{1}
+}
+
+type isLP3Message_OneofUnion interface {
+	isLP3Message_OneofUnion()
+}
+
+type LP3Message_OneofBool struct {
+	OneofBool bool `protobuf:"varint,600,opt,name=oneof_bool,json=oneofBool,proto3,oneof"`
+}
+type LP3Message_OneofInt32 struct {
+	OneofInt32 int32 `protobuf:"varint,601,opt,name=oneof_int32,json=oneofInt32,proto3,oneof"`
+}
+type LP3Message_OneofSint32 struct {
+	OneofSint32 int32 `protobuf:"zigzag32,602,opt,name=oneof_sint32,json=oneofSint32,proto3,oneof"`
+}
+type LP3Message_OneofUint32 struct {
+	OneofUint32 uint32 `protobuf:"varint,603,opt,name=oneof_uint32,json=oneofUint32,proto3,oneof"`
+}
+type LP3Message_OneofInt64 struct {
+	OneofInt64 int64 `protobuf:"varint,604,opt,name=oneof_int64,json=oneofInt64,proto3,oneof"`
+}
+type LP3Message_OneofSint64 struct {
+	OneofSint64 int64 `protobuf:"zigzag64,605,opt,name=oneof_sint64,json=oneofSint64,proto3,oneof"`
+}
+type LP3Message_OneofUint64 struct {
+	OneofUint64 uint64 `protobuf:"varint,606,opt,name=oneof_uint64,json=oneofUint64,proto3,oneof"`
+}
+type LP3Message_OneofFixed32 struct {
+	OneofFixed32 uint32 `protobuf:"fixed32,607,opt,name=oneof_fixed32,json=oneofFixed32,proto3,oneof"`
+}
+type LP3Message_OneofSfixed32 struct {
+	OneofSfixed32 int32 `protobuf:"fixed32,608,opt,name=oneof_sfixed32,json=oneofSfixed32,proto3,oneof"`
+}
+type LP3Message_OneofFloat struct {
+	OneofFloat float32 `protobuf:"fixed32,609,opt,name=oneof_float,json=oneofFloat,proto3,oneof"`
+}
+type LP3Message_OneofFixed64 struct {
+	OneofFixed64 uint64 `protobuf:"fixed64,610,opt,name=oneof_fixed64,json=oneofFixed64,proto3,oneof"`
+}
+type LP3Message_OneofSfixed64 struct {
+	OneofSfixed64 int64 `protobuf:"fixed64,611,opt,name=oneof_sfixed64,json=oneofSfixed64,proto3,oneof"`
+}
+type LP3Message_OneofDouble struct {
+	OneofDouble float64 `protobuf:"fixed64,612,opt,name=oneof_double,json=oneofDouble,proto3,oneof"`
+}
+type LP3Message_OneofString struct {
+	OneofString string `protobuf:"bytes,613,opt,name=oneof_string,json=oneofString,proto3,oneof"`
+}
+type LP3Message_OneofBytes struct {
+	OneofBytes []byte `protobuf:"bytes,614,opt,name=oneof_bytes,json=oneofBytes,proto3,oneof"`
+}
+type LP3Message_OneofChildEnum struct {
+	OneofChildEnum LP3Message_LP3ChildEnum `protobuf:"varint,615,opt,name=oneof_child_enum,json=oneofChildEnum,proto3,enum=google.golang.org.proto3.LP3Message_LP3ChildEnum,oneof"`
+}
+type LP3Message_OneofSiblingEnum struct {
+	OneofSiblingEnum LP3SiblingEnum `protobuf:"varint,616,opt,name=oneof_sibling_enum,json=oneofSiblingEnum,proto3,enum=google.golang.org.proto3.LP3SiblingEnum,oneof"`
+}
+type LP3Message_OneofChildMessage struct {
+	OneofChildMessage *LP3Message_LP3ChildMessage `protobuf:"bytes,617,opt,name=oneof_child_message,json=oneofChildMessage,proto3,oneof"`
+}
+type LP3Message_OneofSiblingMessage struct {
+	OneofSiblingMessage *LP3SiblingMessage `protobuf:"bytes,618,opt,name=oneof_sibling_message,json=oneofSiblingMessage,proto3,oneof"`
+}
+type LP3Message_OneofString1 struct {
+	OneofString1 string `protobuf:"bytes,619,opt,name=oneof_string1,json=oneofString1,proto3,oneof"`
+}
+type LP3Message_OneofString2 struct {
+	OneofString2 string `protobuf:"bytes,620,opt,name=oneof_string2,json=oneofString2,proto3,oneof"`
+}
+type LP3Message_OneofString3 struct {
+	OneofString3 string `protobuf:"bytes,621,opt,name=oneof_string3,json=oneofString3,proto3,oneof"`
+}
+
+func (*LP3Message_OneofBool) isLP3Message_OneofUnion()           {}
+func (*LP3Message_OneofInt32) isLP3Message_OneofUnion()          {}
+func (*LP3Message_OneofSint32) isLP3Message_OneofUnion()         {}
+func (*LP3Message_OneofUint32) isLP3Message_OneofUnion()         {}
+func (*LP3Message_OneofInt64) isLP3Message_OneofUnion()          {}
+func (*LP3Message_OneofSint64) isLP3Message_OneofUnion()         {}
+func (*LP3Message_OneofUint64) isLP3Message_OneofUnion()         {}
+func (*LP3Message_OneofFixed32) isLP3Message_OneofUnion()        {}
+func (*LP3Message_OneofSfixed32) isLP3Message_OneofUnion()       {}
+func (*LP3Message_OneofFloat) isLP3Message_OneofUnion()          {}
+func (*LP3Message_OneofFixed64) isLP3Message_OneofUnion()        {}
+func (*LP3Message_OneofSfixed64) isLP3Message_OneofUnion()       {}
+func (*LP3Message_OneofDouble) isLP3Message_OneofUnion()         {}
+func (*LP3Message_OneofString) isLP3Message_OneofUnion()         {}
+func (*LP3Message_OneofBytes) isLP3Message_OneofUnion()          {}
+func (*LP3Message_OneofChildEnum) isLP3Message_OneofUnion()      {}
+func (*LP3Message_OneofSiblingEnum) isLP3Message_OneofUnion()    {}
+func (*LP3Message_OneofChildMessage) isLP3Message_OneofUnion()   {}
+func (*LP3Message_OneofSiblingMessage) isLP3Message_OneofUnion() {}
+func (*LP3Message_OneofString1) isLP3Message_OneofUnion()        {}
+func (*LP3Message_OneofString2) isLP3Message_OneofUnion()        {}
+func (*LP3Message_OneofString3) isLP3Message_OneofUnion()        {}
+
+func (*LP3Message) XXX_OneofFuncs() (func(proto.Message, *proto.Buffer) error, func(proto.Message, int, int, *proto.Buffer) (bool, error), func(proto.Message) int, []interface{}) {
+	return nil, nil, nil, []interface{}{
+		(*LP3Message_OneofBool)(nil),
+		(*LP3Message_OneofInt32)(nil),
+		(*LP3Message_OneofSint32)(nil),
+		(*LP3Message_OneofUint32)(nil),
+		(*LP3Message_OneofInt64)(nil),
+		(*LP3Message_OneofSint64)(nil),
+		(*LP3Message_OneofUint64)(nil),
+		(*LP3Message_OneofFixed32)(nil),
+		(*LP3Message_OneofSfixed32)(nil),
+		(*LP3Message_OneofFloat)(nil),
+		(*LP3Message_OneofFixed64)(nil),
+		(*LP3Message_OneofSfixed64)(nil),
+		(*LP3Message_OneofDouble)(nil),
+		(*LP3Message_OneofString)(nil),
+		(*LP3Message_OneofBytes)(nil),
+		(*LP3Message_OneofChildEnum)(nil),
+		(*LP3Message_OneofSiblingEnum)(nil),
+		(*LP3Message_OneofChildMessage)(nil),
+		(*LP3Message_OneofSiblingMessage)(nil),
+		(*LP3Message_OneofString1)(nil),
+		(*LP3Message_OneofString2)(nil),
+		(*LP3Message_OneofString3)(nil),
+	}
+}
+
+type LP3Message_LP3ChildMessage struct {
+	F1                   string   `protobuf:"bytes,1,opt,name=f1,proto3" json:"f1,omitempty"`
+	F2                   []string `protobuf:"bytes,2,rep,name=f2,proto3" json:"f2,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (*LP3Message_LP3ChildMessage) Descriptor() ([]byte, []int) {
+	return LP3FileDescriptor, []int{1, 0}
+}
+
+var LP3FileDescriptor = []byte{
+	// 2271 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x59, 0xe7, 0x73, 0x1b, 0xc7,
+	0x15, 0xc7, 0xe1, 0xc0, 0xb6, 0x06, 0x08, 0xe0, 0x20, 0x52, 0x6b, 0xe6, 0xcb, 0x8d, 0xe2, 0x38,
+	0x17, 0xd9, 0xc3, 0x19, 0x12, 0xeb, 0x75, 0x49, 0x6c, 0x45, 0x74, 0xe4, 0x20, 0x1e, 0xdb, 0xd2,
+	0x9c, 0xc2, 0xc9, 0xc4, 0x13, 0x47, 0x01, 0x45, 0x00, 0x86, 0x04, 0xe0, 0x18, 0x12, 0xd0, 0x44,
+	0x33, 0xf9, 0x90, 0xde, 0x93, 0x49, 0xef, 0x7f, 0x42, 0x7a, 0xff, 0x13, 0xd2, 0x7b, 0xb1, 0x9d,
+	0xde, 0xfb, 0x87, 0xcc, 0xa4, 0xf7, 0xd9, 0x7b, 0x5b, 0xef, 0xf6, 0x08, 0x1c, 0x3e, 0x68, 0x04,
+	0x3c, 0xfc, 0xde, 0xfb, 0xed, 0x7b, 0xb7, 0xbf, 0xb7, 0xfb, 0x78, 0xa8, 0x3e, 0xee, 0x1c, 0x8d,
+	0x2f, 0x1d, 0x1c, 0x46, 0xe3, 0xa8, 0xb9, 0x19, 0xff, 0xe7, 0xe1, 0x5e, 0x14, 0xf5, 0x06, 0x9d,
+	0xcd, 0x5e, 0x34, 0x68, 0x8f, 0x7a, 0x9b, 0xd1, 0x61, 0x0f, 0x7e, 0x68, 0x9e, 0x6a, 0xa2, 0xfa,
+	0x03, 0x17, 0x9a, 0x17, 0xfb, 0x7b, 0x83, 0xfe, 0xa8, 0xf7, 0x60, 0xe7, 0xe8, 0xa8, 0xdd, 0xeb,
+	0x78, 0xab, 0xa8, 0xd8, 0xdd, 0xc2, 0x8e, 0xef, 0x04, 0x2b, 0x61, 0xb1, 0xbb, 0x15, 0x7f, 0xdf,
+	0xc6, 0x45, 0xdf, 0x8d, 0xbf, 0x6f, 0x9f, 0xfa, 0xd3, 0xfd, 0x08, 0x3d, 0x70, 0xa1, 0x29, 0xe0,
+	0x4f, 0x46, 0x95, 0xe8, 0x60, 0xdc, 0x8f, 0x46, 0xed, 0xc1, 0xa5, 0xbd, 0x28, 0x1a, 0xe0, 0x7d,
+	0xdf, 0x09, 0x96, 0xc3, 0xb2, 0x30, 0xee, 0x44, 0xd1, 0xc0, 0x7b, 0x0a, 0x5a, 0x95, 0xa0, 0xfe,
+	0x68, 0xdc, 0xdc, 0xc6, 0x1d, 0xdf, 0x09, 0x16, 0x42, 0xe9, 0xfa, 0x1c, 0x66, 0xf4, 0x9e, 0x8a,
+	0xaa, 0x12, 0x76, 0x04, 0xb8, 0xae, 0xef, 0x04, 0xf5, 0x50, 0x7a, 0x5f, 0xec, 0xa7, 0x80, 0x13,
+	0x00, 0xf6, 0x7c, 0x27, 0xa8, 0x28, 0xe0, 0x2e, 0x00, 0x13, 0xc4, 0x94, 0xe0, 0x47, 0x7d, 0x27,
+	0x70, 0x0d, 0x62, 0x4a, 0x52, 0xc4, 0x94, 0xe0, 0xbe, 0xef, 0x04, 0x9e, 0x49, 0x9c, 0x00, 0x4e,
+	0x00, 0x78, 0xc5, 0x77, 0x82, 0x92, 0x49, 0x4c, 0x89, 0xf7, 0x34, 0x54, 0x93, 0xc0, 0x6e, 0xff,
+	0x25, 0x9d, 0xfd, 0xe6, 0x36, 0xbe, 0xea, 0x3b, 0xc1, 0x52, 0x28, 0x03, 0xdc, 0x07, 0x66, 0xef,
+	0x16, 0x54, 0x57, 0xe4, 0x02, 0x3b, 0xf0, 0x9d, 0xa0, 0x1a, 0xca, 0x18, 0x17, 0xb9, 0xdd, 0x48,
+	0xa8, 0x3b, 0x88, 0xda, 0x63, 0x3c, 0xf4, 0x9d, 0xa0, 0xa8, 0x12, 0xba, 0x8f, 0x19, 0xd3, 0xf4,
+	0x94, 0xe0, 0x91, 0xef, 0x04, 0x8b, 0x09, 0x7a, 0x4a, 0x2c, 0xf4, 0x94, 0xe0, 0xc8, 0x77, 0x82,
+	0x5a, 0x92, 0x3e, 0x91, 0xff, 0x7e, 0x34, 0xd9, 0x1b, 0x74, 0xf0, 0x81, 0xef, 0x04, 0x8e, 0xca,
+	0xff, 0x59, 0xb1, 0xd5, 0xac, 0xe8, 0xf8, 0xb0, 0x3f, 0xea, 0xe1, 0x17, 0xc7, 0x5b, 0x4a, 0x55,
+	0x34, 0xb6, 0x1a, 0x09, 0xed, 0x5d, 0x1f, 0x77, 0x8e, 0xf0, 0xa1, 0xef, 0x04, 0x65, 0x95, 0xd0,
+	0x0e, 0x33, 0x7a, 0x6d, 0xd4, 0x90, 0xb0, 0xcb, 0x8f, 0xf6, 0x07, 0xfb, 0x97, 0x3a, 0xa3, 0xc9,
+	0x10, 0x1f, 0xf9, 0x4e, 0xb0, 0xba, 0xbd, 0xb5, 0x99, 0xb5, 0xc5, 0x37, 0xd5, 0x4e, 0x65, 0x1f,
+	0xef, 0x65, 0x9e, 0xe7, 0x46, 0x93, 0x61, 0x28, 0x73, 0x96, 0x26, 0xef, 0x05, 0x68, 0x4d, 0xdb,
+	0x04, 0xb1, 0x26, 0x80, 0x64, 0x1c, 0x93, 0x04, 0xc7, 0x92, 0x70, 0x11, 0xc5, 0xb1, 0x1b, 0x6a,
+	0xd3, 0x48, 0xa3, 0x77, 0x05, 0xad, 0x27, 0x12, 0x18, 0xc2, 0xba, 0xf0, 0xc4, 0x77, 0x82, 0x1b,
+	0xb6, 0x49, 0xae, 0x1c, 0xf8, 0xf7, 0xf0, 0x84, 0x91, 0x86, 0xd0, 0x64, 0x07, 0xe1, 0x54, 0x26,
+	0x82, 0xed, 0x5a, 0xcc, 0x76, 0xcb, 0x2c, 0xc9, 0x08, 0x92, 0xf5, 0x44, 0x3e, 0x82, 0xe6, 0x26,
+	0x54, 0x39, 0xec, 0x1c, 0x74, 0xda, 0xe3, 0xce, 0x3e, 0x48, 0xff, 0xf3, 0x8e, 0xef, 0x32, 0xed,
+	0x0b, 0x6b, 0xac, 0xfd, 0x9b, 0xd1, 0xaa, 0x44, 0x81, 0x54, 0xbf, 0xc0, 0x60, 0x0b, 0xa1, 0x74,
+	0x06, 0xf1, 0x07, 0xa8, 0x2a, 0x71, 0x5c, 0xfc, 0x5f, 0x64, 0xc0, 0x7a, 0x28, 0xfd, 0xb9, 0xfa,
+	0x75, 0x24, 0x57, 0xff, 0x97, 0x18, 0xb2, 0xa2, 0x90, 0x5c, 0xfe, 0x09, 0x6e, 0x4a, 0xf0, 0x97,
+	0x19, 0xd0, 0x35, 0xb8, 0x29, 0x49, 0x71, 0x53, 0x82, 0xbf, 0xc2, 0x80, 0x9e, 0xc9, 0x9d, 0x40,
+	0xf2, 0x06, 0xf0, 0x55, 0x86, 0x2c, 0x99, 0xdc, 0x94, 0x78, 0xa7, 0x51, 0x4d, 0x22, 0x85, 0xaa,
+	0xbf, 0xc6, 0xa0, 0x4b, 0xa1, 0x0c, 0x21, 0x5a, 0xc0, 0xad, 0xa8, 0xae, 0xf8, 0x05, 0xf8, 0xeb,
+	0x0c, 0x5c, 0x0d, 0x65, 0x14, 0xd9, 0x03, 0xf4, 0xac, 0xa0, 0x07, 0x7c, 0x83, 0x41, 0x8b, 0x2a,
+	0x2b, 0x68, 0x02, 0xa9, 0x15, 0x50, 0x82, 0xbf, 0xc9, 0x90, 0x8b, 0x89, 0x15, 0x50, 0x62, 0x59,
+	0x01, 0x25, 0xf8, 0x5b, 0x0c, 0x5c, 0x4b, 0xae, 0x20, 0x51, 0x05, 0xde, 0x06, 0xbe, 0xcd, 0xb0,
+	0x8e, 0xaa, 0x02, 0xef, 0x03, 0x46, 0x65, 0xa1, 0x0f, 0x7c, 0xc7, 0x89, 0xcf, 0x12, 0x55, 0x59,
+	0x68, 0x04, 0x7a, 0x56, 0xd0, 0x08, 0xbe, 0xcb, 0x80, 0x65, 0x95, 0x15, 0x74, 0x82, 0x3d, 0xd4,
+	0x90, 0x38, 0xad, 0x13, 0x7c, 0x8f, 0x81, 0xe7, 0x6b, 0x05, 0x22, 0x9c, 0x6a, 0x05, 0x8f, 0xa0,
+	0x35, 0x6d, 0x3f, 0x68, 0xad, 0xe0, 0x31, 0x60, 0xc9, 0xd1, 0x0b, 0xd4, 0xfe, 0x51, 0xbd, 0xe0,
+	0x2a, 0x5a, 0x4f, 0xa4, 0x20, 0xd4, 0xf9, 0x38, 0x8b, 0x3f, 0x77, 0x33, 0x30, 0x12, 0x11, 0x2a,
+	0xed, 0x22, 0x9c, 0xca, 0x45, 0xd0, 0x3d, 0x01, 0x74, 0xf9, 0xba, 0x41, 0x22, 0x23, 0xc1, 0x73,
+	0x1b, 0x92, 0xfc, 0x97, 0x0e, 0xda, 0x97, 0xaf, 0x8a, 0xa6, 0xf0, 0x21, 0x76, 0x75, 0x58, 0xde,
+	0x29, 0xd6, 0x9c, 0xd0, 0x13, 0x80, 0x0b, 0xf1, 0xef, 0x71, 0x7b, 0xb8, 0x5d, 0x2b, 0x35, 0x77,
+	0x03, 0x49, 0x7f, 0x98, 0xf9, 0x2d, 0xc4, 0x7e, 0x0d, 0xd3, 0x0f, 0xfa, 0xc5, 0x9d, 0x5a, 0x11,
+	0xb9, 0x23, 0x6f, 0x1b, 0x1f, 0x61, 0x9e, 0xf5, 0xd8, 0xf3, 0x84, 0xe9, 0xc9, 0x1b, 0x88, 0xc5,
+	0x95, 0xf7, 0x91, 0x8f, 0x32, 0xd7, 0x8a, 0xcd, 0x95, 0x77, 0x14, 0xfb, 0x72, 0x29, 0xc1, 0x1f,
+	0x63, 0x9e, 0x6e, 0xc6, 0x72, 0x29, 0xc9, 0x5a, 0x2e, 0x25, 0xf8, 0xe3, 0xcc, 0xd3, 0xcb, 0x5a,
+	0xae, 0xdd, 0x95, 0xb7, 0x9e, 0x4f, 0x30, 0xd7, 0x52, 0xd6, 0x72, 0x29, 0xf1, 0x9e, 0x8e, 0x4e,
+	0x26, 0x5d, 0x45, 0x7b, 0xf9, 0x24, 0xf3, 0x5d, 0x8a, 0x7d, 0xd7, 0x4c, 0x5f, 0xd1, 0x95, 0xee,
+	0xd6, 0x76, 0x8e, 0x58, 0xb2, 0xf0, 0xfe, 0x14, 0xf3, 0xae, 0xc6, 0xde, 0xeb, 0x89, 0x45, 0x8b,
+	0x36, 0x65, 0x29, 0x15, 0x74, 0xab, 0x4f, 0x33, 0xdf, 0xa2, 0xad, 0x54, 0xd0, 0xb7, 0xb2, 0x16,
+	0x4d, 0x09, 0xfe, 0x0c, 0x73, 0x5d, 0xcc, 0x5c, 0x34, 0x25, 0xd9, 0x8b, 0xa6, 0x04, 0x7f, 0x96,
+	0x79, 0xd7, 0xb2, 0x17, 0x6d, 0xaf, 0x35, 0x6f, 0x70, 0x9f, 0x63, 0xce, 0x8e, 0xad, 0xd6, 0xbc,
+	0xd5, 0xe9, 0xcb, 0x1e, 0x45, 0x23, 0x5d, 0x03, 0x6f, 0x75, 0xb9, 0x06, 0x0a, 0x6a, 0xd9, 0x0f,
+	0x09, 0x48, 0x2c, 0x03, 0x7d, 0xd9, 0xca, 0x19, 0x36, 0xe5, 0xdb, 0x5c, 0xae, 0x84, 0x82, 0x5a,
+	0xb6, 0xf4, 0x06, 0x31, 0x9c, 0x41, 0x37, 0x5a, 0xdc, 0xb9, 0x1e, 0xde, 0xee, 0x72, 0x3d, 0x14,
+	0xc2, 0x93, 0x29, 0x7f, 0x2e, 0x09, 0x7b, 0x00, 0xae, 0x8a, 0x77, 0xb8, 0x5c, 0x15, 0xb6, 0x00,
+	0x5c, 0x18, 0x99, 0x09, 0x50, 0x82, 0xdf, 0xe9, 0x72, 0x6d, 0x64, 0x24, 0x40, 0xc9, 0x31, 0x09,
+	0x50, 0x82, 0xdf, 0xe5, 0x72, 0x85, 0x64, 0x25, 0x90, 0x19, 0x80, 0xeb, 0xe4, 0xdd, 0x2e, 0xd7,
+	0x49, 0x56, 0x02, 0x94, 0x78, 0x67, 0xd1, 0x86, 0x25, 0x80, 0xd8, 0xef, 0xef, 0x71, 0xb9, 0x5a,
+	0x0a, 0x21, 0x4e, 0x45, 0x10, 0x82, 0xb9, 0x17, 0x3d, 0xc9, 0x96, 0x84, 0x88, 0xf1, 0x5e, 0x97,
+	0x6b, 0xa6, 0x10, 0xde, 0x98, 0x4e, 0xa3, 0x6b, 0x51, 0x9d, 0xb6, 0x8e, 0x58, 0x39, 0xef, 0x73,
+	0xb9, 0x72, 0x6c, 0x85, 0x04, 0xf1, 0x1c, 0x93, 0x06, 0x25, 0xf8, 0xfd, 0x2e, 0xd7, 0x4f, 0x66,
+	0x1a, 0x94, 0x1c, 0x9b, 0x06, 0x25, 0xf8, 0x03, 0x2e, 0x57, 0x51, 0x76, 0x1a, 0x99, 0xcf, 0x83,
+	0x6b, 0xe9, 0x83, 0x2e, 0xd7, 0x92, 0xed, 0x79, 0x70, 0x39, 0x3d, 0x8c, 0x2a, 0xc3, 0xf6, 0x41,
+	0xac, 0x1f, 0x10, 0xd1, 0x9f, 0xdd, 0xf8, 0xb0, 0xba, 0x6d, 0xa6, 0xb3, 0xf1, 0xc1, 0xf6, 0x01,
+	0xd3, 0x15, 0xfb, 0x77, 0x6e, 0x34, 0x3e, 0xbc, 0x1e, 0xde, 0x30, 0x54, 0x16, 0xef, 0x11, 0xb4,
+	0x2a, 0x63, 0xc3, 0x16, 0xff, 0x0b, 0x04, 0xa7, 0x79, 0x82, 0xc7, 0xd2, 0x83, 0xe8, 0xe5, 0xa1,
+	0x66, 0xf2, 0x5e, 0x84, 0xaa, 0x32, 0x3c, 0xd7, 0xe0, 0x5f, 0x21, 0xfe, 0xed, 0x79, 0xe2, 0x83,
+	0x34, 0x81, 0xa0, 0x32, 0xd4, 0x6d, 0x06, 0x03, 0x17, 0xe9, 0xdf, 0xe6, 0x60, 0xd8, 0xb5, 0x30,
+	0x70, 0x3d, 0x27, 0x4a, 0x44, 0x09, 0xfe, 0xfb, 0x7c, 0x25, 0xa2, 0x24, 0x55, 0x22, 0x4a, 0x52,
+	0x25, 0xa2, 0x04, 0xff, 0x63, 0xce, 0x12, 0x09, 0x02, 0xbd, 0x44, 0x09, 0x06, 0xde, 0x06, 0xfe,
+	0x39, 0x67, 0x89, 0x92, 0x0c, 0xbc, 0x63, 0x5c, 0x46, 0x35, 0xc9, 0x20, 0x34, 0xfe, 0x2f, 0xa0,
+	0xb8, 0x23, 0x0f, 0x05, 0x6f, 0x1f, 0xc0, 0xb1, 0x3a, 0x34, 0x8c, 0x5e, 0x17, 0xd5, 0x55, 0xa1,
+	0x04, 0xcb, 0xbf, 0x81, 0xe5, 0xce, 0x5c, 0xa5, 0xea, 0xea, 0x34, 0xd5, 0xa1, 0x69, 0x35, 0x9e,
+	0x37, 0x34, 0x9b, 0xff, 0xcc, 0xf1, 0xbc, 0xe3, 0x1e, 0x64, 0x3e, 0x6f, 0x68, 0x4b, 0xa9, 0x5a,
+	0x51, 0x82, 0xff, 0x3b, 0x6f, 0xad, 0xc4, 0xf3, 0x30, 0x6a, 0x45, 0x89, 0xa5, 0x56, 0x94, 0xe0,
+	0xff, 0xcd, 0x5d, 0x2b, 0x41, 0x63, 0xd6, 0x2a, 0xb1, 0xb5, 0x78, 0x47, 0x7b, 0x59, 0x29, 0xff,
+	0xd6, 0x82, 0x46, 0x67, 0x6e, 0x2d, 0xde, 0xfc, 0x0c, 0x79, 0xc0, 0xd8, 0xf4, 0xf2, 0x39, 0x18,
+	0x60, 0xb4, 0x4a, 0xc8, 0x03, 0xc6, 0x2d, 0xfd, 0x79, 0xc3, 0xb8, 0xf5, 0x8a, 0x52, 0xfe, 0xe7,
+	0x1d, 0x8f, 0x64, 0xe6, 0xf3, 0x86, 0x29, 0xed, 0x0a, 0x6a, 0xc8, 0xf0, 0xda, 0x94, 0xf6, 0x4a,
+	0xe0, 0xb8, 0x2b, 0x0f, 0x87, 0x1c, 0xcb, 0x80, 0xa7, 0x36, 0x4c, 0x98, 0xbd, 0x03, 0xb4, 0xa6,
+	0xf5, 0x12, 0x6d, 0x5a, 0x7b, 0x15, 0xb0, 0x3d, 0x23, 0x5f, 0x47, 0x91, 0x73, 0x1a, 0xf0, 0x79,
+	0xc3, 0xd4, 0x0f, 0xde, 0x11, 0x5a, 0x4f, 0x64, 0x27, 0x26, 0xaa, 0x57, 0x03, 0xe5, 0xdd, 0xb9,
+	0x13, 0xe4, 0x36, 0xe0, 0x6c, 0x0c, 0xd3, 0xbf, 0x78, 0xd7, 0x11, 0x4e, 0xa5, 0x29, 0x68, 0x5f,
+	0x03, 0xb4, 0x67, 0xe6, 0xc8, 0xd4, 0x20, 0x5e, 0x1b, 0xda, 0x7e, 0x13, 0x9b, 0x25, 0x3e, 0x19,
+	0xe0, 0x30, 0x7e, 0x6d, 0xce, 0xcd, 0x12, 0x1f, 0x8c, 0xea, 0x34, 0x66, 0x9b, 0x45, 0x9a, 0xc4,
+	0x6e, 0x3f, 0xd2, 0xe2, 0xbf, 0x2e, 0xe7, 0x6e, 0x87, 0x73, 0x51, 0x11, 0xb0, 0xdd, 0xae, 0x6c,
+	0x82, 0x61, 0xa2, 0x31, 0xbc, 0x3e, 0x27, 0xc3, 0xae, 0x85, 0x41, 0xd9, 0xb4, 0x12, 0x51, 0x02,
+	0x04, 0x6f, 0xc8, 0x5f, 0x22, 0x4a, 0x52, 0x25, 0x02, 0x93, 0x5e, 0x22, 0x11, 0xff, 0x8d, 0x73,
+	0x94, 0x48, 0x27, 0x10, 0x25, 0x32, 0x19, 0x26, 0x1a, 0xc3, 0x9b, 0xe6, 0x28, 0x51, 0x92, 0x41,
+	0xd9, 0xc4, 0x19, 0xc0, 0x4f, 0x1c, 0xa0, 0x78, 0x73, 0x29, 0xdf, 0x19, 0xc0, 0x8f, 0x45, 0xc5,
+	0xc1, 0xaa, 0xae, 0x19, 0x65, 0xa1, 0xe2, 0x2e, 0x07, 0x1c, 0x6f, 0xc9, 0x5b, 0xa8, 0xd8, 0x37,
+	0x51, 0x28, 0x69, 0xf3, 0x7c, 0x84, 0xa2, 0x51, 0x27, 0xea, 0x42, 0xf0, 0xc7, 0x4a, 0xbe, 0x13,
+	0x2c, 0xb7, 0x0a, 0xe1, 0x4a, 0x6c, 0x8c, 0x11, 0xa7, 0xd0, 0x0d, 0x80, 0x80, 0x9b, 0xd9, 0xe3,
+	0x0c, 0xb2, 0xd0, 0x2a, 0x84, 0xe0, 0x07, 0x77, 0xc4, 0x9b, 0x50, 0x19, 0x30, 0xfc, 0x82, 0xf8,
+	0x04, 0x03, 0xd5, 0x5b, 0x85, 0x10, 0x5c, 0xf9, 0x3d, 0x4f, 0xa2, 0xf8, 0x25, 0xef, 0xfb, 0x0c,
+	0x55, 0x91, 0x28, 0x7e, 0x57, 0xd3, 0xf9, 0x28, 0xc1, 0x3f, 0x60, 0x20, 0x57, 0xe7, 0xa3, 0xc4,
+	0xe4, 0xa3, 0x04, 0xff, 0x90, 0x81, 0x3c, 0x83, 0x4f, 0x47, 0xf1, 0x1b, 0xd3, 0x8f, 0x18, 0xaa,
+	0x64, 0xf0, 0x51, 0xe2, 0xdd, 0x8c, 0x2a, 0x80, 0x12, 0xf7, 0x91, 0x1f, 0x33, 0xd8, 0x52, 0xab,
+	0x10, 0x82, 0xb7, 0xb8, 0xbb, 0x04, 0x68, 0x95, 0x73, 0x0a, 0xe0, 0x4f, 0x18, 0xb0, 0xda, 0x2a,
+	0x84, 0x10, 0x40, 0xde, 0x3e, 0x64, 0x06, 0x70, 0xf5, 0xf8, 0x29, 0x83, 0x15, 0x65, 0x06, 0x70,
+	0x85, 0x30, 0x59, 0x29, 0xc1, 0x3f, 0x63, 0xa8, 0x45, 0x93, 0x35, 0xfe, 0xe3, 0xa4, 0xc1, 0x4a,
+	0x09, 0xfe, 0x39, 0x03, 0xd6, 0x12, 0xac, 0x7a, 0xb6, 0xfc, 0x10, 0xff, 0x05, 0xc3, 0x39, 0x32,
+	0x5b, 0x7e, 0x16, 0xab, 0xca, 0xc1, 0x41, 0xfc, 0x4b, 0x86, 0x5a, 0x51, 0x95, 0x83, 0xf3, 0x54,
+	0x66, 0x00, 0x87, 0xe9, 0xaf, 0x18, 0xa8, 0x2c, 0x33, 0x80, 0x43, 0xf1, 0x85, 0xa8, 0x06, 0x18,
+	0xed, 0x44, 0xfc, 0x75, 0x69, 0xce, 0x57, 0x18, 0xad, 0x42, 0x08, 0x79, 0xaa, 0x83, 0xf0, 0xf9,
+	0xc8, 0x13, 0xcf, 0x58, 0x3b, 0x05, 0x7f, 0x53, 0xca, 0xf7, 0xfe, 0xa2, 0x55, 0x08, 0x6b, 0x7c,
+	0x4f, 0xa8, 0x13, 0xaf, 0x87, 0x1a, 0xfa, 0xd2, 0xc5, 0xb9, 0xf3, 0xdb, 0xd2, 0xfc, 0x2f, 0x2f,
+	0x5a, 0x85, 0xb0, 0xae, 0x12, 0x10, 0x47, 0xcd, 0x1e, 0x5a, 0x33, 0x73, 0x10, 0x54, 0xbf, 0x2b,
+	0xe5, 0x7e, 0x73, 0xd1, 0x2a, 0x84, 0x0d, 0x3d, 0x13, 0xc1, 0x21, 0x77, 0x12, 0x3c, 0xd1, 0x2d,
+	0xfc, 0x7b, 0xf1, 0x48, 0xcb, 0xda, 0x23, 0xdd, 0x4a, 0xe2, 0xb6, 0xf1, 0x1f, 0x6c, 0xb8, 0xed,
+	0x24, 0xae, 0x89, 0xff, 0x68, 0xc3, 0x35, 0x37, 0xb6, 0x50, 0x35, 0x51, 0x83, 0x69, 0x6f, 0x5b,
+	0x37, 0xee, 0x41, 0xb5, 0xe4, 0x28, 0xeb, 0xd5, 0x90, 0x7b, 0xb5, 0x73, 0x3d, 0x76, 0x5a, 0x0e,
+	0xd9, 0x47, 0xef, 0x04, 0x5a, 0xb8, 0xd6, 0x1e, 0x4c, 0x3a, 0xb8, 0x18, 0xdb, 0xe0, 0xcb, 0x5d,
+	0xc5, 0x3b, 0x9c, 0x8d, 0x33, 0xa8, 0x9e, 0x9a, 0x56, 0xa7, 0x05, 0x58, 0xd0, 0x03, 0x3c, 0x13,
+	0x79, 0xe9, 0x71, 0x74, 0x5a, 0x84, 0xba, 0x3d, 0xc2, 0xee, 0xec, 0x11, 0x2a, 0x99, 0x49, 0xf0,
+	0x5b, 0xf9, 0xb4, 0x00, 0x6e, 0x76, 0x12, 0x33, 0x46, 0xf0, 0xb2, 0x93, 0x98, 0x31, 0x42, 0x49,
+	0x8f, 0x70, 0x16, 0x35, 0x2c, 0xf3, 0xde, 0xb4, 0x10, 0x4b, 0x7a, 0x88, 0x1d, 0x74, 0xc2, 0x36,
+	0xcc, 0x4d, 0x8b, 0x51, 0xb5, 0xd7, 0x52, 0xcd, 0x6a, 0xd3, 0x02, 0x14, 0x8f, 0xc9, 0x63, 0xc6,
+	0x52, 0x2c, 0x1e, 0x97, 0xc7, 0x8c, 0x31, 0x6a, 0xf6, 0x07, 0xa2, 0x8d, 0x51, 0xd3, 0x22, 0x38,
+	0x19, 0x9b, 0x42, 0x8d, 0x49, 0xd3, 0x22, 0xac, 0xd8, 0x6b, 0xa9, 0xe6, 0xa0, 0x69, 0x01, 0xca,
+	0x7a, 0x80, 0x6b, 0x68, 0xcd, 0x3a, 0xe4, 0x58, 0x82, 0x3c, 0x5b, 0x0f, 0x32, 0xd7, 0x7b, 0x2e,
+	0x8d, 0x37, 0x42, 0x27, 0x33, 0xc6, 0x1d, 0x0b, 0xf3, 0x3d, 0x26, 0xf3, 0xec, 0xef, 0xbe, 0x34,
+	0xc2, 0x97, 0x22, 0x9c, 0x35, 0xec, 0x58, 0x18, 0xef, 0xd7, 0x19, 0xe7, 0x7d, 0x1b, 0xa6, 0xb1,
+	0x4f, 0xd0, 0x46, 0xf6, 0xcc, 0x63, 0xe1, 0x3f, 0x6b, 0xf2, 0xe7, 0x7a, 0x3d, 0x96, 0xda, 0x1e,
+	0xe6, 0xe4, 0xa3, 0xb3, 0x2d, 0x4c, 0x6b, 0xde, 0xb0, 0x43, 0x13, 0xa3, 0x8d, 0x1e, 0xa1, 0x3e,
+	0x5b, 0x84, 0xdd, 0xec, 0x08, 0x95, 0xd9, 0x0e, 0x10, 0x73, 0x36, 0xd1, 0x03, 0xb8, 0xb3, 0x27,
+	0x91, 0x11, 0xc1, 0x9b, 0x3d, 0x89, 0x8c, 0x08, 0xa5, 0x69, 0x11, 0xa0, 0x67, 0x25, 0x67, 0x07,
+	0x3d, 0xc4, 0xd2, 0x8c, 0x69, 0x98, 0xa3, 0x81, 0x1e, 0x61, 0x65, 0x4a, 0x84, 0x53, 0xa7, 0x51,
+	0x59, 0xd7, 0xa3, 0xb7, 0x8c, 0x4a, 0x0f, 0x9f, 0x0b, 0xcf, 0xd7, 0x0a, 0xde, 0x12, 0x72, 0xcf,
+	0x3f, 0x74, 0xae, 0xe6, 0xb0, 0x0f, 0xcf, 0x7d, 0xde, 0xf9, 0x5a, 0x71, 0xa7, 0x22, 0x6e, 0x93,
+	0x93, 0x51, 0x3f, 0x1a, 0x9d, 0xbe, 0x15, 0xad, 0x9a, 0xda, 0x3a, 0xce, 0x79, 0x6f, 0x11, 0x36,
+	0xe7, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x09, 0x11, 0x7d, 0x5b, 0x0c, 0x26, 0x00, 0x00,
+}

internal/impl/legacy_test.go

@@ -0,0 +1,133 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package impl
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/golang/protobuf/v2/internal/pragma"
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+	ptype "github.com/golang/protobuf/v2/reflect/prototype"
+	"github.com/google/go-cmp/cmp"
+)
+
+func mustLoadFileDesc(b []byte) pref.FileDescriptor {
+	fd, err := ptype.NewFileFromDescriptorProto(loadFileDesc(b), nil)
+	if err != nil {
+		panic(err)
+	}
+	return fd
+}
+
+var fileDescLP2 = mustLoadFileDesc(LP2FileDescriptor)
+var fileDescLP3 = mustLoadFileDesc(LP3FileDescriptor)
+
+func TestLegacy(t *testing.T) {
+	tests := []struct {
+		got  pref.Descriptor
+		want pref.Descriptor
+	}{{
+		got:  loadEnumDesc(reflect.TypeOf(LP2MapEnum(0))),
+		want: fileDescLP2.Enums().ByName("LP2MapEnum"),
+	}, {
+		got:  loadEnumDesc(reflect.TypeOf(LP2SiblingEnum(0))),
+		want: fileDescLP2.Enums().ByName("LP2SiblingEnum"),
+	}, {
+		got:  loadEnumDesc(reflect.TypeOf(LP2Message_LP2ChildEnum(0))),
+		want: fileDescLP2.Messages().ByName("LP2Message").Enums().ByName("LP2ChildEnum"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP2Message))),
+		want: fileDescLP2.Messages().ByName("LP2Message"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP2Message_LP2ChildMessage))),
+		want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("LP2ChildMessage"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP2Message_LP2NamedGroup))),
+		want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("LP2NamedGroup"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP2Message_OptionalGroup))),
+		want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("OptionalGroup"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP2Message_RequiredGroup))),
+		want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("RequiredGroup"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP2Message_RepeatedGroup))),
+		want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("RepeatedGroup"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP2SiblingMessage))),
+		want: fileDescLP2.Messages().ByName("LP2SiblingMessage"),
+	}, {
+		got:  loadEnumDesc(reflect.TypeOf(LP3SiblingEnum(0))),
+		want: fileDescLP3.Enums().ByName("LP3SiblingEnum"),
+	}, {
+		got:  loadEnumDesc(reflect.TypeOf(LP3Message_LP3ChildEnum(0))),
+		want: fileDescLP3.Messages().ByName("LP3Message").Enums().ByName("LP3ChildEnum"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP3Message))),
+		want: fileDescLP3.Messages().ByName("LP3Message"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP3Message_LP3ChildMessage))),
+		want: fileDescLP3.Messages().ByName("LP3Message").Messages().ByName("LP3ChildMessage"),
+	}, {
+		got:  loadMessageDesc(reflect.TypeOf(new(LP3SiblingMessage))),
+		want: fileDescLP3.Messages().ByName("LP3SiblingMessage"),
+	}}
+
+	type list interface {
+		Len() int
+		pragma.DoNotImplement
+	}
+	opts := cmp.Options{
+		cmp.Transformer("", func(x list) []interface{} {
+			out := make([]interface{}, x.Len())
+			v := reflect.ValueOf(x)
+			for i := 0; i < x.Len(); i++ {
+				m := v.MethodByName("Get")
+				out[i] = m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
+			}
+			return out
+		}),
+		cmp.Transformer("", func(x pref.Descriptor) map[string]interface{} {
+			out := make(map[string]interface{})
+			v := reflect.ValueOf(x)
+			for i := 0; i < v.NumMethod(); i++ {
+				name := v.Type().Method(i).Name
+				if m := v.Method(i); m.Type().NumIn() == 0 && m.Type().NumOut() == 1 {
+					switch name {
+					case "Index":
+						// Ignore index since legacy descriptors have no parent.
+					case "Messages", "Enums":
+						// Ignore nested message and enum declarations since
+						// legacy descriptors are all created standalone.
+					case "OneofType", "ExtendedType", "MessageType", "EnumType":
+						// Avoid descending into a dependency to avoid a cycle.
+						// Just record the full name if available.
+						//
+						// TODO: Cycle support in cmp would be useful here.
+						v := m.Call(nil)[0]
+						if !v.IsNil() {
+							out[name] = v.Interface().(pref.Descriptor).FullName()
+						}
+					default:
+						out[name] = m.Call(nil)[0].Interface()
+					}
+				}
+			}
+			return out
+		}),
+		cmp.Transformer("", func(v pref.Value) interface{} {
+			return v.Interface()
+		}),
+	}
+
+	for _, tt := range tests {
+		t.Run(string(tt.want.FullName()), func(t *testing.T) {
+			if diff := cmp.Diff(&tt.want, &tt.got, opts); diff != "" {
+				t.Errorf("descriptor mismatch (-want, +got):\n%s", diff)
+			}
+		})
+	}
+}

internal/impl/message.go

@@ -119,7 +119,7 @@ fieldLoop:
 		}
 	}
 	if fn, ok := reflect.PtrTo(t).MethodByName("XXX_OneofFuncs"); ok {
-		vs := fn.Func.Call([]reflect.Value{reflect.New(fn.Type.In(0)).Elem()})[3]
+		vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3]
 	oneofLoop:
 		for _, v := range vs.Interface().([]interface{}) {
 			tf := reflect.TypeOf(v).Elem()

reflect/prototype/protofile_desc.go

@@ -378,7 +378,7 @@ func parseDefault(s string, k protoreflect.Kind) (protoreflect.Value, error) {
 	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
 		v, err := strconv.ParseUint(s, 0, 32)
 		if err == nil {
-			return protoreflect.ValueOf(uint64(v)), nil
+			return protoreflect.ValueOf(uint32(v)), nil
 		}
 	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
 		v, err := strconv.ParseUint(s, 0, 64)

reflect/prototype/standalone.go

@@ -5,6 +5,7 @@
 package prototype
 
 import (
+	"github.com/golang/protobuf/v2/internal/errors"
 	"github.com/golang/protobuf/v2/reflect/protoreflect"
 )
 
@@ -37,6 +38,46 @@ func NewMessage(t *StandaloneMessage) (protoreflect.MessageDescriptor, error) {
 	return mt, nil
 }
 
+// NewMessages creates a set of new protoreflect.MessageDescriptors.
+//
+// This constructor permits the creation of cyclic message types that depend
+// on each other. For example, message A may have a field of type message B,
+// where message B may have a field of type message A. In such a case,
+// a placeholder message is used for these cyclic references.
+//
+// The caller must relinquish full ownership of the input ts and must not
+// access or mutate any fields.
+func NewMessages(ts []*StandaloneMessage) ([]protoreflect.MessageDescriptor, error) {
+	// TODO: Should this be []*T or []T?
+	// TODO: NewMessages is a superset of NewMessage. Do we need NewMessage?
+	ms := map[protoreflect.FullName]protoreflect.MessageDescriptor{}
+	for _, t := range ts {
+		if _, ok := ms[t.FullName]; ok {
+			return nil, errors.New("duplicate message %v", t.FullName)
+		}
+		ms[t.FullName] = standaloneMessage{t}
+	}
+
+	var mts []protoreflect.MessageDescriptor
+	for _, t := range ts {
+		for i, f := range t.Fields {
+			// Resolve placeholder messages with a concrete standalone message.
+			// If this fails, validateMessage will complain about it later.
+			if !f.IsWeak && f.MessageType != nil && f.MessageType.IsPlaceholder() {
+				if m, ok := ms[f.MessageType.FullName()]; ok {
+					t.Fields[i].MessageType = m
+				}
+			}
+		}
+		mt := standaloneMessage{t}
+		if err := validateMessage(mt); err != nil {
+			return nil, err
+		}
+		mts = append(mts, mt)
+	}
+	return mts, nil
+}
+
 // StandaloneEnum is a constructor for a protoreflect.EnumDescriptor
 // that does not have a parent.
 type StandaloneEnum struct {